public void CreateRyu()
{
//load prefabs
PFAlberto = Resources.Load <CAlberto>("Prefabs/PFAlberto");
PFSlime = Resources.Load <CEnemy>("Prefabs/PFSlime");
PFBobby = Resources.Load <CEnemy>("Prefabs/PFBobby");
}
public void SpawnEnemy(Vector3 pos, int line, int sorting)
{
// Spawnea a un enemigo en la ubicacíon pasasda por paramentro
// Y se agrega al manager de enemigos
int pitch = Random.Range(0, 3);
float posYOriginal = pos.y;
pos = new Vector3(pos.x, pos.y + beatTempo + 30, pos.z);
GameObject enemy = GameObject.Instantiate(CEnemyManager.Inst._enemyAsset, pos, Quaternion.identity);
enemy.transform.parent = this.transform;
enemy.GetComponent <SpriteRenderer>().sortingOrder = sorting;
CEnemy enemyccc = enemy.GetComponent <CEnemy>();
enemyccc.beatTempo = beatTempo;
enemyccc._line = line;
enemyccc._pitch = pitch;
enemyccc._lineY = posYOriginal;
CEnemyManager.Inst.addEnemy(enemy.GetComponent <CEnemy>());
}
private void OnTriggerEnter2D(Collider2D collision)
{
if (flight_way < 0)
{
return;
}
if (collision.tag == "Enemy")
{
CEnemy enemy = collision.transform.GetComponent <CEnemy>();
if (enemy != null)
{
enemy.SetHurtValue(Player.weapon.attack, flight_way);
}
if (test)
{
tutorialRequest.DoneHitEnemy();
}
flight_way = -1;
gameObject.SetActive(false);
}
else if (collision.tag == "Wall")
{
flight_way = -1;
gameObject.SetActive(false);
}
}
public void OnUnitDestroyed(CUnit unit)
{
switch (unit.GetUnitType())
{
case UNIT_TYPE.PLAYER:
{
mPlayer = null;
Debug.Log("on player destroyed");
CUIManager.GetInstance().OnUnitDestroyed(unit);
}
break;
case UNIT_TYPE.ENEMY:
{
mEnemy = null;
Debug.Log("on enemy destroyed");
CUIManager.GetInstance().OnUnitDestroyed(unit);
}
break;
}
}
private void UpdateFirstEnemy()
{
for (int i = 0; i < _enemies.Count; i++)
{
if (_firstEnemy == null)
{
_firstEnemy = _enemies[i];
}
else
{
if (_enemies[i].transform.position.x < _firstEnemy.transform.position.x)
{
_firstEnemy = _enemies[i];
}
}
}
Debug.Log("updating first enemy: " + _firstEnemy);
if (_firstEnemy != null)
{
if (_firstEnemy._line == 2 && _firstEnemy._state == CEnemy._STATE_ON)
{
playEnemySfx();
}
}
}
public void spawnEnemy(float x, float y, int type = 0)
{
CEnemy enemy = new CEnemy();
enemy.destroy();
type = type == 0 ? CMath.randomIntBetween(1, 3) : type;
switch (type)
{
case 1:
enemy = (CEnemy) new CSalamandra(CSalamandra.TYPE_DONT_FALL);
break;
case 2:
enemy = (CEnemy) new CGolemTierra(CGolemTierra.TYPE_DONT_FALL);
break;
case 3:
enemy = (CEnemy) new CElementalAgua(CElementalAgua.TYPE_DONT_FALL);
break;
case 4:
enemy = (CEnemy) new CBird(CBird.TYPE_DONT_FALL);
break;
}
enemy.setState(CEnemy.STATE_FALLING);
enemy.setXY(x - enemy.getWidth() / 2, y + enemy.getHeight() / 2);
this.add(enemy);
}
// Use this for initialization
void Start()
{
Debug.Log("CScenePlayGame.Start");
mpUIPlayGame.SetScene(this);
mpUIPlayGame.CreateMy();
mpAlberto = Instantiate <CAlberto>(PFAlberto, Vector3.zero, Quaternion.identity);
mpAlberto.SetScene(this);
mpAlberto.CreateMy();
mEnemyList = new List <CEnemy>();
CEnemy tpEnemy = null;
for (int i = 0; i < ENEMY_SLIME_COUNT; i++)
{
tpEnemy = Instantiate(PFSKeleton, new Vector3((3 + i * 0.5f), 0, 0), Quaternion.identity);
tpEnemy.SetScene(this);
tpEnemy.CreateMy();
mEnemyList.Add(tpEnemy);
}
for (int i = 0; i < ENEMY_REDSLIME_COUNT; i++)
{
tpEnemy = Instantiate(PFRabbit, new Vector3(-(3 + i * 0.5f), 0, 0), Quaternion.identity);
tpEnemy.SetScene(this);
tpEnemy.CreateMy();
mEnemyList.Add(tpEnemy);
}
}
public CEnemy FindClosestEnemy()
{
Debug.Log("fIND CLOSEST ENEMY");
float distanceToClosestEnemy = Mathf.Infinity;
CEnemy closestEnemy = null;
foreach (CEnemy currentEnemy in enemies)
{
if (currentEnemy.IsDead)
{
continue;
}
float distanceToEnemy = (currentEnemy.transform.position - this.transform.position).sqrMagnitude;
if (distanceToEnemy < distanceToClosestEnemy)
{
distanceToClosestEnemy = distanceToEnemy;
closestEnemy = currentEnemy;
}
}
Debug.Log(closestEnemy.gameObject.name);
return(closestEnemy);
Debug.DrawLine(this.transform.position, closestEnemy.transform.position);
}
void DoCreateEnemy()
{
int ti = 0;
if (mEnemyList.Count < 5)
{
ti = mEnemyList.Count;
CEnemy tpSlime = null;
tpSlime = null;
tpSlime = Instantiate <CEnemy>(CRyuGameDataMgr.GetInst().PFSlime, Vector3.zero, Quaternion.identity);
tpSlime.transform.position = new Vector3(-1.0f * Mathf.Pow(-1, ti) * ti, 0, -1.0f * Mathf.Pow(-1, ti - 1) * ti);
tpSlime.SetScene(this);
mEnemyList.Add(tpSlime);
CRyuSoundMgr.GetInst().Play(2);
mEnemyList[ti].CreateAni();
}
else if (5 == mEnemyList.Count)
{
CEnemy tpBobby = null;
tpBobby = null;
tpBobby = Instantiate <CEnemy>(CRyuGameDataMgr.GetInst().PFBobby, Vector3.zero, Quaternion.identity);
tpBobby.transform.position = new Vector3(-5, 0, 0);
tpBobby.SetScene(this);
tpBobby.SetAlberto(mpAlberto);
mEnemyList.Add(tpBobby);
CRyuSoundMgr.GetInst().Play(2);
}
}
private void AimAtEnemy(CEnemy _enemy)
{
Vector3 enemyDirection = _enemy.transform.position - m_GunPivot.position;
float step = AIM_VELOCITY * Time.deltaTime;
/*
* Tried, but even if camera is separated and has it's own script (with lookAt Player) effect is ugly...
// Rotate if enemy is behind you
if (m_RightDirected)
{
// Player is directed to right, but enemy is on the left
if (_enemy.transform.position.x < 0)
{
this.transform.Rotate(Vector3.up, 180.0f);
m_RightDirected = false;
}
}
else
{
// Player is directed to left, but enemy is on the right
if (_enemy.transform.position.x < 0)
{
this.transform.Rotate(Vector3.up, 180.0f);
m_RightDirected = true;
}
}
*/
Vector3 newDir = Vector3.RotateTowards(m_GunPivot.forward, enemyDirection, step, 0.0f);
m_GunPivot.rotation = Quaternion.LookRotation(newDir);
}
private void Start()
{
CEnemy enemy;
//boss獨立給玩家參照
boss = transform.GetChild(0).GetChild(2).GetComponent <CEnemy>();
boss.player = Inplayer;
boss.SetEnemySystem(this);
//所有敵人分別給內外玩家參照
for (int i = 0; i < freeEnemyIn.childCount; i++)
{
enemy = freeEnemyIn.GetChild(i).GetComponent <CEnemy>();
enemy.player = Inplayer;
enemy.SetEnemySystem(this);
// if (i == 1) InEnemys[i].gameObject.SetActive(true);
//InEnemys[i].GetComponent<CEnemy>().attackDetect += Inplayer.OnHurt;
}
for (int i = 0; i < transform.GetChild(1).childCount; i++)
{
enemy = (transform.GetChild(1).GetChild(i)).GetComponent <CEnemy>();
//OutEnemys.Add(enemy.transform);
enemy.IsOut = true;
enemy.player = Outplayer;
enemy.SetEnemySystem(this);
//OutEnemys[i].GetComponent<CEnemy>().player = Outplayer.gameObject;
// if (i == 1) OutEnemys[i].gameObject.SetActive(true);
//InEnemys[i].GetComponent<CEnemy>().attackDetect += Outplayer.OnHurt;
}
if (test)
{
return;
}
}
public void EnemyAttack(CEnemy a_oEnemy)
{
if (m_bIsAttack && a_oEnemy.m_bAttackEnable)
{
if (a_oEnemy.m_bIsDeath)
{
return;
}
var nSkillNumber = Random.Range(1, 3);
var oRandomPlayer = Random.Range(0, 3);
if (m_oPlayers[oRandomPlayer].m_bIsDeath)
{
while (m_oPlayers[oRandomPlayer].m_bIsDeath)
{
oRandomPlayer = Random.Range(0, 3);
if (!m_oPlayers[oRandomPlayer].m_bIsDeath)
{
break;
}
}
}
a_oEnemy.MoveEnemy(nSkillNumber, m_oPlayerTransforms[oRandomPlayer].localPosition);
m_bIsAttack = false;
}
}
public void SpawnEnemy(float x, float y)
{
GameObject obj = Instantiate(mEnemyPrefab);
obj.transform.parent = mUnitRootTransform;
CEnemy enemy = obj.GetComponent <CEnemy>();
enemy.SetPos(x, y);
}
public void CreateRyu()
{
//툴에서 연결하지 않고 소스코드상에서 연결한다.
mpUI = FindObjectOfType <CUI> ();
mpActor = FindObjectOfType <CActor> ();
mpEnemy = FindObjectOfType <CEnemy> ();
mpUI.CreateRyu();
mpUI.SetScene(this);
}
// Use this for initialization
void Start()
{
mpUIPlayGame = GameObject.FindObjectOfType <CUIPlayGame>();
//findObjectOfType 하이어라키 상의 오브젝트를 불러옴
mpUIPlayGame.SetScene(this);
//mpAlberto = Instantiate<CAlberto>(PFAlberto, Vector3.zero, Quaternion.identity);
//mpSlime = Instantiate<CEnemy>(PFSlime, Vector3.zero, Quaternion.identity);
mpAlberto = Instantiate <CAlberto>(CRyuGameDataMgr.GetInst().PFAlberto, Vector3.zero, Quaternion.identity);
mpSlime = Instantiate <CEnemy>(CRyuGameDataMgr.GetInst().PFSlime, Vector3.zero, Quaternion.identity);
}
public void OnTriggerEnter2D(Collider2D other)
{
if (other.CompareTag("Enemy"))
{
CEnemy enemy = other.GetComponent <CEnemy>();
Destroy(gameObject);
if (enemy.Immunity != elementString)
{
enemy.ReceiveSpellDamage(1, element);
}
}
}
public void CreateRyu()
{
//load prefabs
PFAlberto = Resources.Load <CAlberto>("Prefabs/PFAlberto");
PFSlime = Resources.Load <CEnemy>("Prefabs/PFSlime");
PFBobby = Resources.Load <CEnemy>("Prefabs/PFBobby");
PFEnemy_1 = Resources.Load <CEnemy_1>("Prefabs/PFEnemy_1");
PFBulletSphere = Resources.Load <CBullet>("Prefabs/PFBulletSphere");
CreateWithLanguageType();
CreateWithStageData();
}
public void ImOut(CEnemy it)
{
_enemyDeaths += 1;
_enemies.Remove(it);
if (it == _firstEnemy)
{
_firstEnemy = null;
UpdateFirstEnemy();
}
}
private void CreateEnemy(int aIndex)
{
if (aIndex < 0 || aIndex >= CLevelManager.Inst._enemies.Count)
{
return;
}
GameObject enemy = Instantiate(CLevelManager.Inst._enemies[aIndex].prefab, transform);
_currentEnemy = enemy.GetComponent <CEnemy>();
enemy.transform.position = _enemySpawnPonint.position;
_currentEnemy._attackAnim._initialPos = _enemySpawnPonint.localPosition;
_currentEnemy._attackAnim._endPos = _enemyEndPonint.localPosition;
}
public void ReturnEnemy(CEnemy a_oEnemy)
{
a_oEnemy.ReturnEnemy();
for (int i = 0; i < m_oPlayers.Length; ++i)
{
if (!m_oPlayers[i].m_bIsDeath)
{
return;
}
}
m_bIsPlayerOver = true;
}
public void addEnemy(CEnemy newEnemy)
{
_enemies.Add(newEnemy);
if (_firstEnemy == null)
{
_firstEnemy = newEnemy;
if (_firstEnemy._line == 2 && _firstEnemy._state == CEnemy._STATE_ON)
{
playEnemySfx();
}
}
}
public void setEnemiesProlog()
{
visitedEnemies = new List <int>();
Random rand = new Random();
enemies = new CEnemy[3];
for (int x = 0; x < enemies.Length; x++)
{
enemies[x] = new CEnemy {
Left = rand.Next(1, 500), Top = rand.Next(100, 250)
};
enemies[x].Update(enemies[x].Left, enemies[x].Top);
}
}
/// <summary>
/// Check if this beam hit something
/// </summary>
void CheckHit()
{
// Throws a raycast
RaycastHit hit;
if (Physics.Raycast(this.transform.position, v3Direction, out hit, Mathf.Infinity, 1 << 9))
{
// Ok, we have hit an enemy. So, what was his color?
CEnemy enemyScript = hit.transform.parent.gameObject.GetComponent <CEnemy>();
enemyScript.HitBy(myColor, fDamage);
// DEBUG
Debug.Log(this.transform + " Hit in " + hit.transform);
}
}
/* -----------------------------------------------------------------------------------------------------------
* POPULATE
* -----------------------------------------------------------------------------------------------------------
*/
/// <summary>
/// Add the first enemies in the game, for testing purposes
/// </summary>
void PopulateLevelWithEnemies(int nNumberOfEnemies)
{
float fMinAltitude = 35.0f;
float fMaxAltitude = 42.0f;
for (int n = 0; n < nNumberOfEnemies; n++)
{
// Instantiate a new enemy
GameObject goEnemy = Spawner.Spawn(enemyPrefab, Vector3.zero, Quaternion.identity) as GameObject;
CEnemy scriptEnemy = goEnemy.GetComponent <CEnemy>();
int nRandomColor = UnityEngine.Random.Range(0, ColorWheel.Length);
scriptEnemy.Setup(ColorWheel[nRandomColor], UnityEngine.Random.Range(fMinAltitude, fMaxAltitude), UnityEngine.Random.Range(0.0f, 60.0f));
}
}
public void Kick()
{
RaycastHit2D hit = Physics2D.Raycast(_trHitPosition.position, Vector2.zero);
if (hit.collider != null && hit.collider.tag == "Enemy")
{
CEnemy enemy = hit.transform.gameObject.GetComponent <CEnemy>();
if (enemy._eType == CEnemy.ENEMY_TYPE.KICK)
{
enemy.TakeDamaged();
AudioSource.PlayClipAtPoint(_soundHit, CGameManager._pInstance.transform.position);
StartCoroutine(HitEffect());
}
}
}
void SetCondition(CEnemy.Condition cond_, int cond_num_)
{
if (state_cond[cond_num_] == null)
{
switch (cond_)
{
case Condition.NULL:
state_cond[cond_num_] = new ConditionChecker(OnThisState);
break;
case Condition.CheckTime:
state_cond[cond_num_] = new ConditionChecker(CheckTime);
break;
case Condition.CheckOneFrame:
state_cond[cond_num_] = new ConditionChecker(CheckOneFrame);
break;
case Condition.CheckLeftSide:
state_cond[cond_num_] = new ConditionChecker(CheckLeftSide);
break;
case Condition.CheckRightSide:
state_cond[cond_num_] = new ConditionChecker(CheckRightSide);
break;
case Condition.CheckUpperSide:
state_cond[cond_num_] = new ConditionChecker(CheckUpperSide);
break;
case Condition.CheckLowerSide:
state_cond[cond_num_] = new ConditionChecker(CheckLowerSide);
break;
case Condition.CheckDistance:
state_cond[cond_num_] = new ConditionChecker(CheckDistance);
break;
case Condition.CheckDistanceX:
state_cond[cond_num_] = new ConditionChecker(CheckDistanceX);
break;
case Condition.CheckDistanceY:
state_cond[cond_num_] = new ConditionChecker(CheckDistanceY);
break;
case Condition.CheckRadius:
state_cond[cond_num_] = new ConditionChecker(CheckRadius);
break;
case Condition.CheckHP:
state_cond[cond_num_] = new ConditionChecker(CheckHP);
break;
default:
break;
}
}
}
public void Initialize(EnemyStatus enemy_,
CEnemy.AI AI_type_)
{
max_HP = enemy_.HP;
HP = max_HP;
ATK = enemy_.ATK;
speed = enemy_.SPD;
DEF = enemy_.DEF;
coin_amount = enemy_.coin_amount;
score = enemy_.score;
ai_phase = 0;
current_animation = AnimationName.normal;
SetShooter();
SetAI(AI_type_);
}
IEnumerator RegenEnemy()
{
yield return(new WaitForSeconds(3f));
while (true)
{
int randEnemyIdx = Random.Range(0, _prefEnemys.Length);
CEnemy enemy = Instantiate(_prefEnemys[randEnemyIdx],
_trEnemyRegenPos[randEnemyIdx].position, Quaternion.identity).GetComponent <CEnemy>();
enemy.DoInit();
enemy.transform.SetParent(_trEnemyPrent);
yield return(new WaitForSeconds(2f));
}
}
public void AddFreeList(Transform trans)
{
Debug.Log("recycle enemy" + enemyNumber);
CEnemy temp = trans.GetComponent <CEnemy>();
float side = temp.whichSide;
trans.parent = freeEnemyIn;
trans.gameObject.SetActive(false);
enemyNumber--;
//deathNumber++;
if (StageManager.currentStage < 7)
{
if (Mathf.Abs(side) > 0.5f)
{ //如果回收的敵人有占住一個攻擊位置，把位置給其他人
if (side > 0.1f)
{
canAttackLoc[1] = true;
}
else if (side < -0.1f)
{
canAttackLoc[0] = true;
}
for (int i = 0; i < UsedEnemyIn.childCount; i++)
{
temp = UsedEnemyIn.GetChild(i).GetComponent <CEnemy>();
if (Mathf.Abs(temp.whichSide) < 0.2f)
{
Debug.Log("get position");
if (canAttackLoc[0])
{
Debug.Log("left");
temp.whichSide = -1.0f;
canAttackLoc[0] = false;
}
else if (canAttackLoc[1])
{
Debug.Log("right");
temp.whichSide = 1.0f;
canAttackLoc[1] = false;
}
}
}
}
}
}
/// <summary>
/// Called when the player succesfully completes a sequence.
/// </summary>
public void OnSequenceComplete()
{
if (_currentEnemy == null && _currentHeart == null)
{
return;
}
if (_currentHeart != null)
{
_currentHeart.SetState(CHeart.STATE_PICKED_UP);
_currentHeart = null;
}
else
{
_currentEnemy.SetDead(true);
_currentEnemy = null;
}
_elapsedTimeNoEnemy = 0;
_timeToWaitBetweenEnemies = CMath.RandomFloatBetween(CLevelManager.Inst.GetCurrentTimeEnemySpawn().x, CLevelManager.Inst.GetCurrentTimeEnemySpawn().y);
_ui.SetSequence(new List <Runes>());
_ui.SetClockValue(0);
_mercenary.SetState(CMercenary.STATE_ATTACK);
}
private void Update()
{
if (GameData.IsPause)
{
return;
}
if (_currentEnemy == null && _currentHeart == null)
{
_elapsedTimeNoEnemy += Time.deltaTime;
if (_elapsedTimeNoEnemy > _timeToWaitBetweenEnemies)
{
_elapsedTimeNoEnemy = 0;
_ui.SetClockValue(0);
_timeToWaitBetweenEnemies = CMath.RandomFloatBetween(CLevelManager.Inst.GetCurrentTimeEnemySpawn().x, CLevelManager.Inst.GetCurrentTimeEnemySpawn().y);
SpawnEnemy();
return;
}
}
else
{
if (_currentEnemy != null && _currentEnemy.IsDead())
{
_currentEnemy = null;
_elapsedTimeNoEnemy = 0;
_ui.SetClockValue(0);
_timeToWaitBetweenEnemies = CMath.RandomFloatBetween(CLevelManager.Inst.GetCurrentTimeEnemySpawn().x, CLevelManager.Inst.GetCurrentTimeEnemySpawn().y);
}
if (_currentHeart != null && _currentHeart.IsDead())
{
_currentHeart = null;
_elapsedTimeNoEnemy = 0;
_ui.SetClockValue(0);
_timeToWaitBetweenEnemies = CMath.RandomFloatBetween(CLevelManager.Inst.GetCurrentTimeEnemySpawn().x, CLevelManager.Inst.GetCurrentTimeEnemySpawn().y);
}
}
}
void DoCreateEnemy()
{
int tSceneNum = CRyuGameDataMgr.GetInst().SceneLoadNum;
mCount = mEnemyList.Count;
if (mEnemyList.Count < CRyuGameDataMgr.GetInst().mStageInfoBundle.mStageInfoList[tSceneNum].mUnitInfoList.Count)
{
CEnemy tpSlime = null;
tpSlime = Instantiate <CEnemy>(CRyuGameDataMgr.GetInst().PFSlime, Vector3.zero, Quaternion.identity);
tpSlime.transform.position = new Vector3(CRyuGameDataMgr.GetInst().mStageInfoBundle.mStageInfoList[tSceneNum].mUnitInfoList[mCount].mX,
CRyuGameDataMgr.GetInst().mStageInfoBundle.mStageInfoList[tSceneNum].mUnitInfoList[mCount].mY,
CRyuGameDataMgr.GetInst().mStageInfoBundle.mStageInfoList[tSceneNum].mUnitInfoList[mCount].mZ);
tpSlime.SetScene(this);
mEnemyList.Add(tpSlime);
mEnemyList[mCount].CreateAni();
CRyuSoundMgr.GetInst().Play(2);
}
/*
* int ti = 0;
* if (mEnemyList.Count < 5)
* {
* ti = mEnemyList.Count;
* CEnemy tpSlime = null;
*
* tpSlime = null;
* tpSlime = Instantiate<CEnemy>(CRyuGameDataMgr.GetInst().PFSlime, Vector3.zero, Quaternion.identity);
* tpSlime.transform.position = new Vector3(-1.0f * Mathf.Pow(-1, ti) * ti, 0, -1.0f * Mathf.Pow(-1, ti - 1) * ti);
* tpSlime.SetScene(this);
*
* mEnemyList.Add(tpSlime);
* CRyuSoundMgr.GetInst().Play(2);
*
* mEnemyList[ti].CreateAni();
* }
* else if (5 == mEnemyList.Count)
* {
* CEnemy tpBobby = null;
* tpBobby = null;
* tpBobby = Instantiate<CEnemy>(CRyuGameDataMgr.GetInst().PFBobby, Vector3.zero, Quaternion.identity);
* tpBobby.transform.position = new Vector3(-5, 0, 0);
* tpBobby.SetScene(this);
* tpBobby.SetAlberto(mpAlberto);
* mEnemyList.Add(tpBobby);
* CRyuSoundMgr.GetInst().Play(2);
* }
* else if(6==mEnemyList.Count)
* {
* CEnemy_1 tpEnemy_1= null;
* tpEnemy_1 = null;
* tpEnemy_1 = Instantiate<CEnemy_1>(CRyuGameDataMgr.GetInst().PFEnemy_1, Vector3.zero, Quaternion.identity);
* tpEnemy_1.transform.position = new Vector3(-5, 0, 0);
* tpEnemy_1.SetScene(this);
* tpEnemy_1.SetAlberto(mpAlberto);
* mEnemyList.Add(tpEnemy_1);
* CRyuSoundMgr.GetInst().Play(2);
*
*
*
*
* }
*/
}
void SetAI(CEnemy.AI ai_type_)
{
switch (ai_type_) {
case AI.Test:
my_AI = new EventHandler (Test);
break;
case AI.Test2:
my_AI = new EventHandler (Test2);
break;
case AI.Eye_Cross_L350:
my_AI = new EventHandler (Eye_Cross_L350);
break;
case AI.Eye_Cross_R350:
my_AI = new EventHandler (Eye_Cross_R350);
break;
case AI.Eye_Cross_L0:
my_AI = new EventHandler (Eye_Cross_L0);
break;
case AI.Eye_Cross_R0:
my_AI = new EventHandler (Eye_Cross_R0);
break;
case AI.Eye_Cross_L_Shooter:
my_AI = new EventHandler (Eye_Cross_L_Shooter);
break;
case AI.Eye_Cross_R_Shooter:
my_AI = new EventHandler (Eye_Cross_R_Shooter);
break;
case AI.Eye_Turn_L0:
my_AI = new EventHandler (Eye_Turn_L0);
break;
case AI.Eye_Turn_L350:
my_AI = new EventHandler (Eye_Turn_L350);
break;
case AI.Eye_Turn_R0:
my_AI = new EventHandler (Eye_Turn_R0);
break;
case AI.Eye_Turn_R350:
my_AI = new EventHandler (Eye_Turn_R350);
break;
case AI.Eye_Zig_L0:
my_AI = new EventHandler (Eye_Zig_L0);
break;
case AI.Eye_Zig_R0:
my_AI = new EventHandler (Eye_Zig_R0);
break;
case AI.Eye_Down:
my_AI = new EventHandler (Eye_Down);
break;
case AI.Eye_Back:
my_AI = new EventHandler (Eye_Back);
break;
case AI.Eye_Turn_L_Back:
my_AI = new EventHandler (Eye_Turn_L_Back);
break;
case AI.Eye_Turn_R_Back:
my_AI = new EventHandler (Eye_Turn_R_Back);
break;
case AI.Cloud_Down:
my_AI = new EventHandler (Cloud_Down);
break;
case AI.Bat_Rush:
my_AI = new EventHandler (Bat_Rush);
break;
case AI.Bee_Cross_L:
my_AI = new EventHandler (Bee_Cross_L);
break;
case AI.Bee_Cross_R:
my_AI = new EventHandler (Bee_Cross_R);
break;
case AI.Bee_Slide_L:
my_AI = new EventHandler (Bee_Slide_L);
break;
case AI.Bee_Slide_R:
my_AI = new EventHandler (Bee_Slide_R);
break;
case AI.Bee_SlideUp_L:
my_AI = new EventHandler (Bee_SlideUp_L);
break;
case AI.Bee_SlideUp_R:
my_AI = new EventHandler (Bee_SlideUp_R);
break;
case AI.Bee_Tic_R:
my_AI = new EventHandler (Bee_Tic_R);
break;
case AI.Bee_Tic_L:
my_AI = new EventHandler (Bee_Tic_L);
break;
case AI.Bee_Tic_T:
my_AI = new EventHandler (Bee_Tic_T);
break;
case AI.Bird_Down_L:
my_AI = new EventHandler (Bird_Down_L);
break;
case AI.Bird_Down_R:
my_AI = new EventHandler (Bird_Down_R);
break;
case AI.Shielder2_Wat_L:
my_AI = new EventHandler (Shielder2_Wat_L);
break;
case AI.Shielder2_Wat_R:
my_AI = new EventHandler (Shielder2_Wat_R);
break;
case AI.Shielder2_Wat_T:
my_AI = new EventHandler (Shielder2_Wat_T);
break;
case AI.Shielder1_Cross_L:
my_AI = new EventHandler (Shielder1_Cross_L);
break;
case AI.Shielder1_Cross_R:
my_AI = new EventHandler (Shielder1_Cross_R);
break;
case AI.Shielder1_Zig_L:
my_AI = new EventHandler (Shielder1_Zig_L);
break;
case AI.Shielder1_Zig_R:
my_AI = new EventHandler (Shielder1_Zig_R);
break;
case AI.Shooter1_Cross_L_1:
my_AI = new EventHandler (Shooter1_Cross_L_1);
break;
case AI.Shooter1_Wat_L_1:
my_AI = new EventHandler (Shooter1_Wat_L_1);
break;
case AI.Shooter1_Wat_R_1:
my_AI = new EventHandler (Shooter1_Wat_R_1);
break;
case AI.Shooter1_Wat_T_1:
my_AI = new EventHandler (Shooter1_Wat_T_1);
break;
case AI.Shooter1_Cross_R_1:
my_AI = new EventHandler (Shooter1_Cross_R_1);
break;
case AI.Shooter1_Slide_L_1:
my_AI = new EventHandler (Shooter1_Slide_L_1);
break;
case AI.Shooter1_Slide_R_1:
my_AI = new EventHandler (Shooter1_Slide_R_1);
break;
case AI.Shooter1_SlideUp_L_1:
my_AI = new EventHandler (Shooter1_SlideUp_L_1);
break;
case AI.Shooter1_SlideUp_R_1:
my_AI = new EventHandler (Shooter1_SlideUp_R_1);
break;
case AI.Shooter2_FollowX:
my_AI = new EventHandler (Shooter2_FollowX);
break;
case AI.Shooter2_DWait_L:
my_AI = new EventHandler (Shooter2_DWait_L);
break;
case AI.Shooter2_DWait_R:
my_AI = new EventHandler (Shooter2_DWait_R);
break;
case AI.Shooter2_Wait_L:
my_AI = new EventHandler (Shooter2_DWait_L);
break;
case AI.Shooter2_Wait_R:
my_AI = new EventHandler (Shooter2_DWait_R);
break;
case AI.Shooter2_Down:
my_AI = new EventHandler (Shooter2_Down);
break;
case AI.Shooter3_Tic_T_1:
my_AI = new EventHandler (Shooter3_Tic_T_1);
break;
case AI.Shooter3_Tic_T_2:
my_AI = new EventHandler (Shooter3_Tic_T_2);
break;
case AI.Shooter3_Wat_T_1:
my_AI = new EventHandler (Shooter3_Wat_T_1);
break;
case AI.Shooter3_Wat_T_2:
my_AI = new EventHandler (Shooter3_Wat_T_2);
break;
case AI.Shooter3_Wat_L_1:
my_AI = new EventHandler (Shooter3_Wat_L_1);
break;
case AI.Shooter3_Wat_L_2:
my_AI = new EventHandler (Shooter3_Wat_L_2);
break;
case AI.Shooter3_Wat_R_1:
my_AI = new EventHandler (Shooter3_Wat_R_1);
break;
case AI.Shooter3_Wat_R_2:
my_AI = new EventHandler (Shooter3_Wat_R_2);
break;
case AI.Squirrel1_Wait_L:
my_AI = new EventHandler (Squirrel1_Wait_L);
break;
case AI.Squirrel1_Wait_R:
my_AI = new EventHandler (Squirrel1_Wait_R);
break;
case AI.Squirrel1_DWait_L:
my_AI = new EventHandler (Squirrel1_DWait_L);
break;
case AI.Squirrel1_DWait_R:
my_AI = new EventHandler (Squirrel1_DWait_R);
break;
case AI.Squirrel2_Wait_L:
my_AI = new EventHandler (Squirrel2_Wait_L);
break;
case AI.Squirrel2_Wait_R:
my_AI = new EventHandler (Squirrel2_Wait_R);
break;
case AI.Squirrel2_DWait_L:
my_AI = new EventHandler (Squirrel2_DWait_L);
break;
case AI.Squirrel2_DWait_R:
my_AI = new EventHandler (Squirrel2_DWait_R);
break;
case AI.Squirrel2_Wat_R:
my_AI = new EventHandler (Squirrel2_Wat_R);
break;
case AI.Squirrel2_Wat_T:
my_AI = new EventHandler (Squirrel2_Wat_T);
break;
case AI.Squirrel2_Wat_L:
my_AI = new EventHandler (Squirrel2_Wat_L);
break;
case AI.Roselia_1:
my_AI = new EventHandler (Roselia_1);
break;
case AI.Firebird_C:
my_AI = new EventHandler (Firebird_C);
break;
case AI.Firebird_R:
my_AI = new EventHandler (Firebird_R);
break;
case AI.Icebird_1:
my_AI = new EventHandler (Icebird_1);
break;
case AI.Icebird_Long:
my_AI = new EventHandler (Icebird_Long);
break;
case AI.Honglin_1:
my_AI = new EventHandler (Honglin_1);
break;
case AI.Sullin_1:
my_AI = new EventHandler (Sullin_1);
break;
case AI.Hedgehog_1:
my_AI = new EventHandler (Hedgehog_1);
break;
case AI.IceTurtle_1:
my_AI = new EventHandler (IceTurtle_1);
break;
case AI.Hedgehog_L:
my_AI = new EventHandler (Hedgehog_L);
break;
case AI.IceTurtle_R:
my_AI = new EventHandler (IceTurtle_R);
break;
case AI.ChampBat_F:
my_AI = new EventHandler (ChampBat_F);
break;
case AI.QueenBee_1:
my_AI = new EventHandler (QueenBee_1);
break;
case AI.BoyBee_1:
my_AI = new EventHandler (BoyBee_1);
break;
case AI.GirlBee_1:
my_AI = new EventHandler (GirlBee_1);
break;
case AI.Down:
my_AI = new EventHandler (Down);
break;
case AI.Wat_T:
my_AI = new EventHandler (Wat_T);
break;
case AI.Wat_R:
my_AI = new EventHandler (Wat_R);
break;
case AI.Wat_L:
my_AI = new EventHandler (Wat_L);
break;
case AI.Cross_L:
my_AI = new EventHandler (Cross_L);
break;
case AI.Cross_R:
my_AI = new EventHandler (Cross_R);
break;
case AI.Zig_L:
my_AI = new EventHandler (Zig_L);
break;
case AI.Zig_R:
my_AI = new EventHandler (Zig_R);
break;
case AI.Turn_L:
my_AI = new EventHandler (Turn_L);
break;
case AI.Turn_R:
my_AI = new EventHandler (Turn_R);
break;
case AI.Wait_L:
my_AI = new EventHandler (Wait_L);
break;
case AI.Wait_R:
my_AI = new EventHandler (Wait_R);
break;
case AI.DWait_L:
my_AI = new EventHandler (DWait_L);
break;
case AI.DWait_R:
my_AI = new EventHandler (DWait_R);
break;
case AI.Tic_L:
my_AI = new EventHandler (Tic_L);
break;
case AI.Tic_R:
my_AI = new EventHandler (Tic_R);
break;
case AI.Tic_T:
my_AI = new EventHandler (Tic_T);
break;
case AI.Slide_L:
my_AI = new EventHandler (Slide_L);
break;
case AI.Slide_R:
my_AI = new EventHandler (Slide_R);
break;
case AI.Re_T:
my_AI = new EventHandler (Re_T);
break;
default :
break;
}
}
void DoAction(CEnemy.Action act_, Vector3 vector_)
{
switch (act_)
{
case Action.NULL:
break;
case Action.MoveDirction:
if (MoveDirection(vector_))
{
gameObject.transform.Translate(moved_pos,Space.World);
}
break;
case Action.MovePosition:
if (MovePosition(vector_))
{
gameObject.transform.Translate(moved_pos,Space.World);
}
break;
case Action.MoveKeepGoing:
if (MoveKeepGoing(vector_))
{
gameObject.transform.Translate(moved_pos, Space.World);
}
break;
case Action.MoveAxisTrace:
if (MoveAxisTrace(vector_))
{
gameObject.transform.Translate(moved_pos, Space.World);
}
break;
case Action.MoveTrace:
if (MoveTrace(vector_))
{
gameObject.transform.Translate(moved_pos, Space.World);
}
break;
case Action.TurnShooter:
if (ShootingAngle(false, vector_))
{
TurnShooter(shooting_angle[(int)vector_.z], (int)vector_.z);
}
break;
case Action.RotateShooter:
if (ShootingAngle(true, vector_))
{
RotateShooter(shooting_angle[(int)vector_.z], (int)vector_.z);
}
break;
case Action.ShootOnce:
if (!shoot_once[(int)vector_.z])
{
if (SelectShooter((int)vector_.x, (int)vector_.y, (int)vector_.z))
{
ShootOnce((int)vector_.z);
shoot_once[(int)vector_.z] = true;
}
}
break;
case Action.StartShooting:
if (!shooting[(int)vector_.z])
{
if (SelectShooter((int)vector_.x, (int)vector_.y, (int)vector_.z))
{
shooting[(int)vector_.z] = true;
StartShooting((int)vector_.z);
}
}
break;
case Action.StopShooting:
if (shooting[(int)vector_.z])
{
shooting[(int)vector_.z] = false;
StopShooting((int)vector_.z);
}
break;
case Action.PlayAnimation:
if(CheckAnimation((int)vector_.z))
{
PlayAnimation((AnimationName)(int)vector_.z);
}
break;
default:
break;
}
}
// Use this for initialization
void Awake()
{
enemy = transform.parent.GetComponent <CEnemy>();
}
bool StateAction(CEnemy.Condition cond_, float cond_param_, CEnemy.Action act_, Vector3 act_param_, int next_phase_, int cond_num_ = 0)
{
SetCondition(cond_,cond_num_);
if (state_cond[cond_num_](cond_param_))
{
ai_phase = next_phase_;
for (int i = 0; i < 5; i++)
{
state_cond[i] = null;
}
for (int i = 0; i < shooter_amount; i++)
{
shoot_once[i] = false;
}
return false;
}
else
{
DoAction(act_, act_param_);
return true;
}
}
IEnumerator SummonEnemy(int number_of_summon,
EnemyStatus enemy_,
CEnemy.AI AI_type,
CEnemy.StartPosition start_position,
float delay = 0.5f)
{
GameObject enemy;
enemy = ResourceLoad.PickGameObject(enemy_.name.ToString());
for (int formation = 0; formation < number_of_summon; formation++)
{
GameObject temp = (GameObject)Instantiate(enemy, CEnemy.GetStartPosition(start_position), Quaternion.identity);
CEnemy temp_enemy = temp.GetComponent<CEnemy>();
temp_enemy.Initialize(enemy_, AI_type);
yield return new WaitForSeconds(delay);
}
}
public IEnumerator SummonEnemy(float summon_time,
int number_of_summon,
EnemyStatus enemy_,
CEnemy.AI AI_type_,
CEnemy.StartPosition start_position,
float delay = 0.5f)
{
GameObject enemy;
enemy = ResourceLoad.PickGameObject(enemy_.name.ToString());
yield return new WaitForSeconds(summon_time);
level_difficulty = StageManager.LevelDifficulty;
if (0 < level_difficulty)
{
enemy_.ATK *= (1 + (level_difficulty - 1) * 1.8f);
enemy_.HP *= (1 + (level_difficulty - 1) * 1.1f);
enemy_.score += (level_difficulty - 1) * 100;
}
for (int formation = 0; formation < number_of_summon; formation++)
{
GameObject temp = (GameObject)Instantiate(enemy, CEnemy.GetStartPosition(start_position), Quaternion.identity);
CEnemy temp_enemy = temp.GetComponent<CEnemy>();
temp_enemy.Initialize(enemy_, AI_type_);
yield return new WaitForSeconds(delay);
}
}
