// When enemy is down, deactivate object(not destroy) and returns missiles in memory pool
void Dead()
{
for (int i = 0; i < Missile1.Length; i++)
{
if (Missile1[i])
{
Missile1[i].GetComponent <Collider2D>().enabled = true;
MPool1.RemoveItem(Missile1[i]);
Missile1[i] = null;
}
}
for (int i = 0; i < Missile2.Length; i++)
{
if (Missile2[i])
{
Missile2[i].GetComponent <Collider2D>().enabled = true;
MPool2.RemoveItem(Missile2[i]);
Missile2[i] = null;
}
}
for (int i = 0; i < Missile3.Length; i++)
{
if (Missile3[i])
{
Missile3[i].GetComponent <Collider2D>().enabled = true;
MPool3.RemoveItem(Missile3[i]);
Missile3[i] = null;
}
}
EventSP.GetComponent <Event_ScoreHP>().BossDeathCheck = true;
gameObject.SetActive(false);
}
/* 미사일 발사 */
void MissileFire()
{
if (GetComponent <Enemy_Info>().FireState)
{
StartCoroutine(FireCycleControl());
for (int i = 0; i < MissileMaximumPool; i++)
{
if (Missile[i] == null)
{
Missile[i] = MPool.NewItem();
Missile[i].GetComponent <Enemy_Missile>().Damage = GetComponent <Enemy_Info>().Damage;
Missile[i].transform.position = MissileLocation.transform.position;
break;
}
}
}
/* 미사일을 다시 메모리풀로 돌려보냄 */
for (int i = 0; i < MissileMaximumPool; i++)
{
if (Missile[i])
{
if (Missile[i].GetComponent <Collider2D>().enabled == false)
{
Missile[i].GetComponent <Collider2D>().enabled = true;
MPool.RemoveItem(Missile[i]);
Missile[i] = null;
}
}
}
}
bool MissileFire()
{
if (FireState)
{
if (Input.GetButton("Fire1"))
{
// 미사일 발사 속도 제어
StartCoroutine(FireCycleControl());
// 미사일 메모리풀에서 냠냠
for (int i = 0; i < MissileMaximumPool / 2; i++)
{
if (MissileLeft[i] == null && MissileRight[i] == null)
{
MissileLeft[i] = MPool.NewItem();
MissileRight[i] = MPool.NewItem();
MissileLeft[i].transform.position = LeftMissileLocation.transform.position;
MissileRight[i].transform.position = RightMissileLocation.transform.position;
break;
}
}
MissileSound.Play();
}
}
// 미사일 메모리풀로 되돌려보내기
for (int i = 0; i < MissileMaximumPool / 2; i++)
{
if (MissileLeft[i])
{
if (MissileLeft[i].GetComponent <Collider2D>().enabled == false)
{
MissileLeft[i].GetComponent <Collider2D>().enabled = true;
MPool.RemoveItem(MissileLeft[i]);
MissileLeft[i] = null;
}
}
if (MissileRight[i])
{
if (MissileRight[i].GetComponent <Collider2D>().enabled == false)
{
MissileRight[i].GetComponent <Collider2D>().enabled = true;
MPool.RemoveItem(MissileRight[i]);
MissileRight[i] = null;
}
}
}
return(true);
}
private void PlayerFire()
{
if (FireState)
{
if (Input.GetKey(KeyCode.A))
{
StartCoroutine(FireCycleControl());
for (int i = 0; i < BulletMaxPool; i++)
{
if (BulletArray[i] == null)
{
BulletArray[i] = mPool.NewItem();
BulletArray[i].transform.position = BulletLocation.transform.position;
break;
}
}
}
}
for (int i = 0; i < BulletMaxPool; i++)
{
if (BulletArray[i])
{
if (BulletArray[i].GetComponent <Collider2D>().enabled == false)
{
BulletArray[i].GetComponent <Collider2D>().enabled = true;
mPool.RemoveItem(BulletArray[i]);
BulletArray[i] = null;
}
}
}
}
private void PlayerFire()
{
if (MissileStatus)
{
if (Input.GetKey(KeyCode.A))
{
StartCoroutine(MissileCycleControl());
for (int i = 0; i < MissileMaxPool; i++)
{
if (MissileArray[i] == null)
{
MissileArray[i] = Mpool.newItem();
MissileArray[i].transform.position = MissileLocation.transform.position;
break;
}
}
}
}
for (int i = 0; i < MissileMaxPool; i++)
{
if (MissileArray[i])
{
if (MissileArray[i].GetComponent <Collider2D>().enabled == false)
{
MissileArray[i].GetComponent <Collider2D>().enabled = true;
Mpool.RemoveItem(MissileArray[i]);
MissileArray[i] = null;
}
}
}
}
IEnumerator FireEffect(Vector3 pos, Quaternion rot)
{
GameObject bulletHole, flare;
bulletHole = bulletHolePool.NewItem();
flare = flarePool.NewItem();
if (bulletHole)
{
bulletHole.transform.position = pos;
bulletHole.transform.SetParent(fireTraceParent);
bulletHole.transform.rotation = rot;
flare.transform.position = pos;
flare.transform.SetParent(fireTraceParent);
flare.transform.rotation = rot;
}
yield return(new WaitForSeconds(0.5f));
flarePool.RemoveItem(flare, hitSparkPrefab, fireTraceParent);
yield return(new WaitForSeconds(0.5f));
bulletHolePool.RemoveItem(bulletHole, hitHolePrefab, fireTraceParent);
}
private void Shoot()
{
if (lazerState)
{
if (Input.GetKey(KeyCode.X))
{
StartCoroutine(LazerCycleControl());
for (int i = 0; i < lazerMaxPool; i++)
{
if (lazerArray[i] == null)
{
lazerArray[i] = MPool.NewItem();
lazerArray[i].transform.position = lazerLocation.transform.position;
break;
}
}
}
}
for (int i = 0; i < lazerMaxPool; i++)
{
if (lazerArray[i])
{
if (lazerArray[i].GetComponent <Collider2D>().enabled == false)
{
lazerArray[i].GetComponent <Collider2D>().enabled = true;
MPool.RemoveItem(lazerArray[i]);
lazerArray[i] = null;
}
}
}
}
// 적생성
bool Enemy_Create()
{
if (enemy_State)
{
for (int i = 0; i < enemy1.Length; i++)
{
if (enemy1[i] == null)
{
enemy1[i] = enemy1_pool.NewItem();
enemy1[i].transform.position = new Vector3(Random.Range(-EnemySpawnMaxXpos, EnemySpawnMaxXpos), this.Player.transform.position.y + 0.3f, 8f);
}
}
enemy_State = false;
Debug.Log("Enemy.cs : 적 생성 완료");
}
for (int i = 0; i < enemy1.Length; i++)
{
if (enemy1[i])
{
if (enemy1[i].transform.position.z < DestroyEnemyZpos)
{
enemy1_pool.RemoveItem(enemy1[i]);
enemy1[i] = null;
Enemy_Death_Counter++;
}
else if (enemy1[i].GetComponent <Collider>().enabled == false)
{
Score += 20;
ScoreManager.Score_Manager(Score);
enemy1[i].GetComponent <Collider>().enabled = true;
enemy1_pool.RemoveItem(enemy1[i]);
enemy1[i] = null;
Enemy_Death_Counter++;
Debug.Log("Enemy.cs : 적 제거 완료");
}
}
// 만약에 적을 다 죽였다면 다시 적을 생성하도록 enemy_State를 true로 만든다.
if (Enemy_Death_Counter == Enemy1Count)
{
level++;
Enemy_Death_Counter = 0;
enemy_State = true;
}
}
return(true);
}
IEnumerator TxtEffectReset(GameObject txtEffect, int index)
{
yield return(new WaitForSeconds(0.5f));
txtEffect.GetComponent <RhythmTxt_Controller>().ResetEffect();
memoryPoolEffect.RemoveItem(txtEffect);
Effect[index] = null;
}
// 미사일을 발사하는 함수
private void playerFire()
{
// 제어변수가 true일때만 발동
if (FireState)
{
// 키보드의 "J"를 누르면
if (Input.GetKey(KeyCode.J))
{
Player_Animator.SetBool("Shotting", true);
// 코루틴 "FireCycleControl"이 실행되며
StartCoroutine(FireCycleControl());
// 미사일 풀에서 발사되지 않은 미사일을 찾아서 발사합니다.
for (int i = 0; i < MissileMaxPool; i++)
{
// 만약 미사일배열[i]가 비어있다면
if (MissileArray[i] == null)
{
// 메모리풀에서 미사일을 가져온다.
MissileArray[i] = MPool.NewItem();
// 해당 미사일의 위치를 미사일 발사지점으로 맞춘다.
MissileArray[i].transform.position = MissileLocation.transform.position;
// 발사 후에 for문을 바로 빠져나간다.
break;
}
}
}
if (Input.GetKey(KeyCode.K))
{
//총알 장전
}
//else
//{
// Player_Animator.SetBool("Shotting", false);
//}
}
// 미사일이 발사될때마다 미사일을 메모리풀로 돌려보내는 것을 체크한다.
for (int i = 0; i < MissileMaxPool; i++)
{
// 만약 미사일[i]가 활성화 되어있다면
if (MissileArray[i])
{
// 미사일[i]의 Collider2D가 비활성 되었다면
if (MissileArray[i].GetComponent <Collider2D>().enabled == false)
{
// 다시 Collider2D를 활성화 시키고
MissileArray[i].GetComponent <Collider2D>().enabled = true;
// 미사일을 메모리로 돌려보내고
MPool.RemoveItem(MissileArray[i]);
// 가리키는 배열의 해당 항목도 null(값 없음)로 만든다.
MissileArray[i] = null;
}
}
}
}
// 미사일을 발사하는 함수
void stoneCamp()
{
// 제어변수가 true이고 발사할 Click이 남아 있을 때만 발동
if (FireState)
{
GameObject startingPoint = GameObject.Find("StoneCamp");
float curX = startingPoint.transform.position.x;
float curY = startingPoint.transform.position.y;
startingPoint.transform.position = new Vector3(curX, Random.Range(-4, 4), 0);
// 코루틴 "FireCycleControl"이 실행되며
StartCoroutine(FireCycleControl());
// 미사일 풀에서 발사되지 않은 미사일을 찾아서 발사합니다.
for (int i = 0; i < EnemyMaxPool; i++)
{
// 만약 미사일배열[i]가 비어있다면
if (EnemyArray[i] == null)
{
// 메모리풀에서 미사일을 가져온다.
EnemyArray[i] = MPool.NewItem();
// 해당 미사일의 위치를 미사일 발사지점으로 맞춘다.
EnemyArray[i].transform.position = StartingPoint.transform.position;
// 발사 후에 for문을 바로 빠져나간다.
break;
}
}
// Clicks 감소
}
// 미사일이 발사될때마다 미사일을 메모리풀로 돌려보내는 것을 체크한다.
for (int i = 0; i < EnemyMaxPool; i++)
{
// 만약 미사일[i]가 활성화 되어있다면
if (EnemyArray[i])
{
// 미사일[i]의 Collider2D가 비활성 되었다면
if (EnemyArray[i].GetComponent <Collider2D>().enabled == false)
{
// 다시 Collider2D를 활성화 시키고
EnemyArray[i].GetComponent <Collider2D>().enabled = true;
// 미사일을 메모리로 돌려보내고
MPool.RemoveItem(EnemyArray[i]);
// 가리키는 배열의 해당 항목도 null(값 없음)로 만든다.
EnemyArray[i] = null;
}
}
}
}
//void BulletEffect()
//{
// Quaternion randomQuaternion = new Quaternion(Random.Range(0, 360f), Random.Range(0, 360f), Random.Range(180, 360f), 1);
// GameObject casing = Instantiate(bulletCasing, bulletCasingPoint);
// casing.transform.localRotation = randomQuaternion;
// casing.GetComponent<Rigidbody>().AddRelativeForce(new Vector3(Random.Range(50f, 100f), Random.Range(50f, 100f), Random.Range(-30f, 30f)));
// Destroy(casing, 1f);
//}
IEnumerator BloodEffect(Vector3 pos)
{
GameObject bloodParticleTemp;
bloodParticleTemp = bloodParticlePool.NewItem();
if (bloodParticleTemp)
{
bloodParticleTemp.transform.position = pos;
bloodParticleTemp.transform.SetParent(fireTraceParent);
}
yield return(new WaitForSeconds(1.0f));
bloodParticlePool.RemoveItem(bloodParticleTemp, bloodParticlePrefab, fireTraceParent);
}
// 미사일을 발사하는 함수
public void spaceshipWithClicks()
{
// 제어변수가 true이고 발사할 Click이 남아 있을 때만 발동
if (FireState)
{
if (FireShoot && (FireCount < FireLimit))
{
// 사용자가 발사 버튼을 누르면
FireShoot = false;
// 코루틴 "FireCycleControl"이 실행되며
StartCoroutine(FireCycleControl());
// 미사일 풀에서 발사되지 않은 미사일을 찾아서 발사합니다.
for (int i = 0; i < MissileMaxPool; i++)
{
// 만약 미사일배열[i]가 비어있다면
if (MissileArray[i] == null)
{
// 메모리풀에서 미사일을 가져온다.
MissileArray[i] = MPool.NewItem();
// 해당 미사일의 위치를 미사일 발사지점으로 맞춘다.
MissileArray[i].transform.position = MissileLocation.transform.position;
// 발사 후에 for문을 바로 빠져나간다.
break;
}
}
}
}
// 미사일이 발사될때마다 미사일을 메모리풀로 돌려보내는 것을 체크한다.
for (int i = 0; i < MissileMaxPool; i++)
{
// 만약 미사일[i]가 활성화 되어있다면
if (MissileArray[i])
{
// 미사일[i]의 Collider2D가 비활성 되었다면
if (MissileArray[i].GetComponent <Collider2D>().enabled == false)
{
// 다시 Collider2D를 활성화 시키고
MissileArray[i].GetComponent <Collider2D>().enabled = true;
// 미사일을 메모리로 돌려보내고
MPool.RemoveItem(MissileArray[i]);
// 가리키는 배열의 해당 항목도 null(값 없음)로 만든다.
MissileArray[i] = null;
}
}
}
}
// When enemy is down, deactivate object(not destroy) and returns missiles in memory pool
void Dead()
{
for (int i = 0; i < Missile1.Length; i++)
{
if (Missile1[i])
{
Missile1[i].GetComponent <Collider2D>().enabled = true;
MPool1.RemoveItem(Missile1[i]);
Missile1[i] = null;
}
}
Boss4.GetComponent <Boss_Level4>().RightDead = true;
gameObject.SetActive(false);
}
void Update()
{
// 미사일이 생성되자마자 MissileSpeed 속도로 날라감
this.transform.Translate(new Vector3(0, 0, -1) * EnemySpeed * Time.deltaTime);
if (Missile_Fire_State)
{
Invoke("Missile_Fire_Cur", MissileFireSpeed);
for (int i = 0; i < enemy_missile.Length; i++)
{
if (enemy_missile[i] == null)
{
enemy_missile[i] = missile_pool.NewItem();
enemy_missile[i].transform.position = EnemyFireLocation.transform.position;
break;
}
}
Missile_Fire_State = false;
}
for (int i = 0; i < enemy_missile.Length; i++)
{
if (enemy_missile[i])
{
if (enemy_missile[i].transform.position.z < DestroyMissileZpos)
{
missile_pool.RemoveItem(enemy_missile[i]);
enemy_missile[i] = null;
}
else if (enemy_missile[i].GetComponent <Collider>().enabled == false)
{
enemy_missile[i].GetComponent <Collider>().enabled = true;
missile_pool.RemoveItem(enemy_missile[i]);
enemy_missile[i] = null;
}
}
}
}
private void RhythmGameNoteDelete(RhythmGameNoteDeleteMsg msg)
{
Message.Send <RhythmGameNoteJudgeMsg>(new RhythmGameNoteJudgeMsg(msg.rhythmNote));
if (msg.isNoTouch)
{
if (msg.isRight)
{
memoryPoolRight.RemoveItem(msg.note);
RightNote[msg.index] = null;
}
else
{
memoryPoolLeft.RemoveItem(msg.note);
LeftNote[msg.index] = null;
}
}
else
{
for (int i = 0; i < 10; i++)
{
if (Effect[i] == null)
{
Effect[i] = memoryPoolEffect.NewItem();
Effect[i].transform.localPosition = new Vector3(0, 0.3f, 1);
Effect[i].transform.localScale = new Vector3(noteItem.transform.localScale.x, noteItem.transform.localScale.y, noteItem.transform.localScale.z);
Effect[i].GetComponent <RhythmTxt_Controller>().SetEffect(msg.rhythmNote);
StartCoroutine(TxtEffectReset(Effect[i], i));
break;
}
}
msg.note.GetComponent <RhythmGameNote_Controller>().TouchEffect();
StartCoroutine(NoteTouchAni(msg.isRight, msg.note, msg.index));
}
}
void CheckBoardRow()
{
bool isCleared = false;
int count = 0;
foreach (Transform row in boardNode)
{
if (row.childCount == boardWidth)
{
count++;
foreach (Transform each in row)
{
pool.RemoveItem(each.gameObject);
}
row.DetachChildren();
isCleared = true;
}
}
gameManager.IncreseScore(count);
if (isCleared)
{
int target = 0;
for (int i = 0; i < boardNode.childCount; ++i)
{
var row = boardNode.Find(i.ToString());
if (row.childCount == 0)
{
continue;
}
if (i != target)
{
var targetNode = boardNode.Find(target.ToString());
while (row.childCount > 0)
{
var node = row.GetChild(0);
node.parent = targetNode;
node.transform.localPosition = new Vector2(node.localPosition.x, 0);
}
row.DetachChildren();
}
target++;
}
}
}
IEnumerator AniCheck()
{
while (true)
{
yield return(null);
for (int i = 0; i < 10; i++)
{
if (TouchEffects[i] != null && !TouchEffects[i].GetComponent <ParticleSystem>().isPlaying)
{
memoryPoolTouch.RemoveItem(TouchEffects[i]);
TouchEffects[i] = null;
break;
}
}
}
}
//Spawn one piece of food
//now it spawn random food using 'INT' position!
void Spawnf()
{
if (FoodSpwanState)
{
// 시간 대기를 위한 코루틴 실행
StartCoroutine(FoodspawnCycleControl());
// Memory Pool 에서 생성되지 않은 먹이를 찾아서 생성
for (int i = 0; i < FoodMaxPool; i++)
{
if (FoodprefabArray[i] == null)
{
FoodprefabArray[i] = MPool.NewItem();
//x position between left and right border
float x = (float)Random.Range(border_Left.position.x,
border_Right.position.x);
//y position between top and bottom border
float y = (float)Random.Range(border_Top.position.y,
border_Bottom.position.y);
float z = -(float)food_size;
FoodprefabArray[i].transform.position = new Vector3(x, y, z);
FoodprefabArray[i].transform.localScale = new Vector3(food_size, food_size, food_size);
FoodprefabArray[i].GetComponent <Light>().color = new Color32(255, 255, 255, 255);
FoodprefabArray[i].GetComponent <Light>().range = food_halo_size;
FoodprefabArray[i].GetComponent <foodinfo>().type = (FoodType)Random.Range(0, 11);
break;
}
}
}
for (int i = 0; i < FoodMaxPool; i++)
{
if (FoodprefabArray[i])
{
if (FoodprefabArray[i].activeSelf == false)
{
FoodprefabArray[i].SetActive(true);
MPool.RemoveItem(FoodprefabArray[i]);
FoodprefabArray[i] = null;
}
}
}
}
private void BossFire() // 파이어볼을 발사하는 함수
{
// 제어변수가 true일때만 발동
if (FireState)
{
StartCoroutine(FireCycleControl()); // 코루틴 "FireCycleControl"이 실행되며
for (int i = 0; i < FireBallMaxPool; i++) // 파이어볼 풀에서 발사되지 않은 파이어볼을 찾아서 발사
{
if (FireBallArray[i] == null) // 만약 화살배열[i]가 비어있다면
{
FireBallArray[i] = FireBallMPool.NewItem(); // 메모리풀에서 파이어볼을 가져옴
FireBallArray[i].transform.position = FireBallLocation.transform.position; // 해당 파이어볼의 위치를 파이어볼 발사지점으로 맞춤
FireBallArray[i].GetComponent <FireBallMove>().dir = transform.right; // X축 기준으로 발사
GameObject.Find("Boss_2_Attack").GetComponent <AudioSource>().Play();
break; // 발사 후에 for문을 바로 빠져나감
}
}
}
for (int i = 0; i < FireBallMaxPool; i++) // 파이어볼이 발사될때마다 파이어볼을 메모리풀로 돌려보내는 것을 체크
{
if (FireBallArray[i]) // 만약 파이어볼[i]가 활성화 되어있다면
{
if (FireBallArray[i].GetComponent <BoxCollider>().enabled == false) // 파이어볼[i]의 Collider가 비활성 되었다면
{
FireBallArray[i].GetComponent <BoxCollider>().enabled = true; // 다시 Collider를 활성화 시키고
FireBallMPool.RemoveItem(FireBallArray[i]); // 파이어볼을 메모리로 돌려보내고
FireBallArray[i] = null; // 가리키는 배열의 해당 항목도 null(값 없음)로 만듦
}
}
}
// 코루틴 함수
IEnumerator FireCycleControl()
{
FireState = false; // 처음에 FireState를 false로 만들고
yield return(new WaitForSeconds(FireDelay)); // FireDelay초 후에
FireState = true; // FireState를 true로 만든다.
}
}
IEnumerator BulletEffect()
{
GameObject bulletCasingObject;
bulletCasingObject = bulletCasingPool.NewItem();
Quaternion randomQuaternion = new Quaternion(Random.Range(0, 360f), Random.Range(0, 360f), Random.Range(180, 360f), 1);
if (bulletCasingObject)
{
bulletCasingObject.transform.position = transform.TransformPoint(transform.InverseTransformPoint(bulletCasingPoint.position) + new Vector3(0.4f, 0, 0.3f));
bulletCasingObject.transform.localScale = new Vector3(2, 2, 2);
bulletCasingObject.transform.SetParent(fireTraceParent);
bulletCasingObject.transform.localRotation = randomQuaternion;
//bulletCasingObject.GetComponent<Rigidbody>().AddRelativeForce(new Vector3(Random.Range(0.01f, 0.05f), Random.Range(0.01f, 0.05f), Random.Range(-0.03f, 0.03f)));
bulletCasingObject.GetComponent <Rigidbody>().AddRelativeForce(new Vector3(Random.Range(50f, 100f), Random.Range(50f, 100f), Random.Range(-30f, 30f)));
}
yield return(new WaitForSeconds(1f));
bulletCasingPool.RemoveItem(bulletCasingObject, bulletCasingPrefab, fireTraceParent);
}
// Update is called once per frame
void Update()
{
float amtMove = speed * Time.deltaTime;
float key = Input.GetAxis("Horizontal");
transform.Translate(Vector3.right * key * amtMove);
shootTimeLeft = Time.time - startTime;
//발사
if (Input.GetMouseButtonDown(0))
{
if (shootTimeLeft > fireRate)
{
for (int i = 0; i < missile.Length; i++)
{
if (missile[i] == null)
{
missile[i] = pool.NewItem();
missile[i].transform.position = transform.position;
break;
}
}
startTime = Time.time;
shootTimeLeft = 0.0f;
}
}
//미사일삭제
for (int i = 0; i < missile.Length; i++)
{
if (missile[i])
{
if (missile[i].transform.position.z > 20)
{
pool.RemoveItem(missile[i]);
// missile[i].GetComponent<CsMissile>().init();
missile[i] = null;
}
}
}
}
// Update is called once per frame
void Update()
{
if (true) //어떤 조건에 의해 화살이 생길때!
{
for (int i = 0; i < Arrow.Length; ++i)
{
if (Arrow[i] == null)
{
Arrow[i] = pool.NewItem();
//에로우 첫포지션 등 셋팅
break;
}
}
}
for (int i = 0; i < Arrow.Length; ++i)
{
if (Arrow[i])
{
//어떤 조건에 의거하여 화살이 지워져야할때
pool.RemoveItem(Arrow[i]);
Arrow[i] = null;
}
}
}
/* 공격 했을 때 */
bool Attack()
{
if (Gun_Fire_State)
{
if (Input.GetKey(KeyCode.A))
{
// FireSpeed에 맞춰 실행
Invoke("FireSpeedControl", FireSpeed);
// 미사일 활성화 및 발사(미리 생성해놓은 메모리 에서 가져옴)
for (int i = 0; i < missile_left.Length; i++)
{
if (missile_left[i] == null && missile_right[i] == null)
{
missile_right[i] = pool.NewItem();
missile_left[i] = pool.NewItem();
missile_right[i].transform.position = FireMissileRightLocation.transform.position;
missile_left[i].transform.position = FireMissileLeftLocation.transform.position;
break;
}
}
Debug.Log("Attack_Missile.cs : 총 발사됨");
Gun_Fire_State = false;
MissileFire.Play();
}
}
/* 미사일 메모리로 다시 돌려보냄 */
for (int i = 0; i < missile_left.Length; i++)
{
// 왼쪽 미사일이 활성화 되어 있을 시
if (missile_left[i])
{
// 미사일이 DestoryMissileZpos 이상으로 움직였을 시 돌려보냄
if (missile_left[i].transform.position.z > DestroyMissileZpos)
{
pool.RemoveItem(missile_left[i]);
missile_left[i] = null;
Debug.Log("Attack_Missile.cs : 거리에서 벗어남");
}
// 미사일의 콜라이더가 비활성화 됬을시 돌려보냄(미사일이 적에게 부딛혔을 때)
else if (missile_left[i].GetComponent <Collider>().enabled == false)
{
Debug.Log("Attack_Missile.cs : 적과 충돌함");
missile_left[i].GetComponent <Collider>().enabled = true;
pool.RemoveItem(missile_left[i]);
missile_left[i] = null;
}
}
// 오른쪽 미사일이 활성화 되어 있을 시
if (missile_right[i])
{
// 미사일이 DestoryMissileZpos 이상으로 움직였을 시 돌려보냄
if (missile_right[i].transform.position.z > DestroyMissileZpos)
{
pool.RemoveItem(missile_right[i]);
missile_right[i] = null;
Debug.Log("Attack_Missile.cs : 거리에서 벗어남");
}
// 미사일의 콜라이더가 비활성화 됬을시 돌려보냄(미사일이 적에게 부딛혔을 때)
else if (missile_right[i].GetComponent <Collider>().enabled == false)
{
missile_right[i].GetComponent <Collider>().enabled = true;
pool.RemoveItem(missile_right[i]);
missile_right[i] = null;
Debug.Log("Attack_Missile.cs : 적과 충돌함");
}
}
}
return(true);
}
// Update is called once per frame
void Update()
{
if (InputManager_JHW.LTriggerOn() && InputManager_JHW.RTriggerOn())
{
if (MyState.GetMyState() == PlayerState.State.Nomal)
{
MyState.SetMyState(PlayerState.State.Attack);
if (currentCorutine == null)
{
flug = true;
switch (LineDraw.curType)
{
case 0: //아즈라 공격 형태 기를 모으는 형태, 오큘러스 터치의 충돌에서 출발하여 양손을 벌릴때 점차 커지며 방출
{
currentCorutine = StartCoroutine(AzuraControll());
}
break;
case 1: // 화살의 형태 화살을 장전한채로 트리거를 누르고 있을 시 기를 모아 방출
{
currentCorutine = StartCoroutine(SeikwanControll());
}
break;
case 2: //전격 공격, 총알 발사 형태, 몬스터를 타겟하여 전격을 발사 형태, 저격 된 상태에서 기를 모아 방출
{
currentCorutine = StartCoroutine(BeejaeControll());
}
break;
case 3: // 양 컨트롤러의 포인터가 맞춰졌을대 발동, 트리거를 계속 on하면 기를 모아 방출 베르베시
{
currentCorutine = StartCoroutine(VerbaseControll());
}
break;
case 4: //바이올린 상태 전체 공격 위주, 한정된 시간에 여러번 좌우 이동을 통해 차징 공격
{
currentCorutine = StartCoroutine(DellControll());
}
break;
}
}
}
}
else if ((!InputManager_JHW.RTriggerOn() && !InputManager_JHW.LTriggerOn()) && flug)
{
flug = false;
MyState.SetMyState(PlayerState.State.Nomal);
SettingOff();
}
if (MyState.GetMyState() == PlayerState.State.ChargingOver)
{
SettingOff();
}
if (LineDraw.curType == 1)
{
for (int i = 0; i < Arrow.Length; ++i)
{
if (Arrow[i])
{
if (Arrow[i].GetComponent <SeiKwanSkill>().IsDelete())
{
Arrow[i].GetComponent <SeiKwanSkill>().resetDelete();
Arrowpool.RemoveItem(Arrow[i]);
Arrow[i] = null;
}
//어떤 조건에 의거 Arrow삭제
}
}
}
else if (LineDraw.curType == 0)
{
for (int i = 0; i < AzuraBall.Length; ++i)
{
if (AzuraBall[i])
{
if (AzuraBall[i].GetComponent <AzuraSkill>().IsDelete())
{
AzuraBall[i].GetComponent <AzuraSkill>().resetDelete();
Azurapool.RemoveItem(AzuraBall[i]);
AzuraBall[i] = null;
}
//어떤 조건에 의거 AzuraBall삭제
}
}
}
}
void Update()
{
float axis = 1;
bool isDown = Input.GetAxisRaw("Vertical") < 0;
if (Input.GetButtonDown("Jump"))
{
rig2d.velocity = new Vector2(rig2d.velocity.x, 5);
}
//var distanceFromGround = Physics2D.Raycast (transform.position, Vector3.down, 1f, groundMask);
// update animator parameters
animator.SetBool(hashIsCrouch, isDown);
//animator.SetFloat (hashGroundDistance, distanceFromGround.distance == 0 ? 99 : distanceFromGround.distance - characterHeightOffset);
animator.SetFloat(hashFallSpeed, rig2d.velocity.y);
animator.SetFloat(hashSpeed, Mathf.Abs(axis));
//if( CharacterControllManager.GetInstance.m_normalAttackCheck )
// {
// animator.SetTrigger(hashAttack1);
// }
//if(CharacterControllManager.GetInstance.m_normalAttackAnimCheck)
// {
// animator.SetTrigger(hashAttack2);
// }
//if(CharacterControllManager.GetInstance.m_skillAnimCheck)
// {
// animator.SetTrigger(hashAttack3);
// }
// flip sprite
if (axis != 0)
{
spriteRenderer.flipX = axis < 0;
}
if (m_distance == DISTANCE.E_SHORTTYPE)
{
ShotTypeMotionCheck();
}
else if (m_distance == DISTANCE.E_LONGTYPE)
{
LongTypeMotionCheck();
}
else if (m_distance == DISTANCE.E_MIXTYPE)
{
MixTypeMotionCheck();
}
for (int i = 0; i < m_bullet.Length; i++)
{
if (m_bullet[i])
{
if (m_collCheck)
{
m_bulletpool.RemoveItem(m_bullet[i]);
m_bullet[i] = null;
}
m_collCheck = false;
}
}
}
// 화살을 발사하는 함수
private void playerFire()
{
// 제어변수가 true일때만 발동
if (FireState)
{
// 키보드의 "A"를 누르면
if (Input.GetKey(KeyCode.A))
{
// 코루틴 "FireCycleControl"이 실행되며
StartCoroutine(FireCycleControl());
// 화살풀에서 발사되지 않은 화살을 찾아서 발사합니다.
for (int i = 0; i < ArrowMaxPool; i++)
{
// 만약 화살배열[i]가 비어있다면
if (ArrowArray[i] == null)
{
// 메모리풀에서 화살을 가져온다.
ArrowArray[i] = MPool.NewItem();
// 해당 화살의 위치를 화살 발사지점으로 맞춘다.
ArrowArray[i].transform.position = ArrowLocation.transform.position;
ArrowArray[i].GetComponent <ArrowMove>().dir = transform.right;
//공격 애니메이션 끄는 타이밍
animatorA.SetBool("isAttack", false);
// 발사 후에 for문을 바로 빠져나간다.
break;
}
}
}
}
// 화살이 발사될때마다 화살을 메모리풀로 돌려보내는 것을 체크한다.
for (int i = 0; i < ArrowMaxPool; i++)
{
// 만약 화살[i]가 활성화 되어있다면
if (ArrowArray[i])
{
// 화살[i]의 Collider가 비활성 되었다면
if (ArrowArray[i].GetComponent <BoxCollider>().enabled == false)
{
// 다시 Collider를 활성화 시키고
ArrowArray[i].GetComponent <BoxCollider>().enabled = true;
// 화살을 메모리로 돌려보내고
MPool.RemoveItem(ArrowArray[i]);
// 가리키는 배열의 해당 항목도 null(값 없음)로 만든다.
ArrowArray[i] = null;
}
}
}
// 코루틴 함수
IEnumerator FireCycleControl()
{
// 처음에 FireState를 false로 만들고
FireState = false;
// FireDelay초 후에
yield return(new WaitForSeconds(FireDelay));
// FireState를 true로 만든다.
FireState = true;
}
}
// 미사일을 발사하는 함수
private void playerFire()
{
// 제어변수가 true일때만 발동
if (FireState)
{
// 키보드의 "A"를 누르면
//if (Input.GetKey(KeyCode.A))
{
// 코루틴 "FireCycleControl"이 실행되며
StartCoroutine(FireCycleControl());
int indexPosition = Random.Range(0, firePositionCount);
float randomScale = Random.Range(3.0f, 6.0f);
int tCount = 0;
// 미사일 풀에서 발사되지 않은 미사일을 찾아서 발사합니다.
float time = timer.GetTime();
if ((time / timeIter) > 1.0f)
{
timeIter += timeTick;
MissileArraySize += 10;
MissileArraySize = MissileArraySize >= MissileMaxPool ? (MissileMaxPool - 1) : MissileArraySize;
Debug.Log("Increases missile - " + MissileArraySize);
}
for (int i = 0; i < MissileArraySize; i++)
{
// 만약 미사일배열[i]가 비어있다면
if (MissileArray[i] == null)
{
// 메모리풀에서 미사일을 가져온다.
MissileArray[i] = MPool.NewItem();
// 해당 미사일의 위치를 미사일 발사지점으로 맞춘다.
//MissileArray[i].transform.position = MissileLocation.transform.position;
MissileArray[i].transform.position = firePosition[indexPosition];
MissileArray[i].transform.localScale = new Vector3(randomScale, randomScale, randomScale);
// 발사 후에 for문을 바로 빠져나간다.
//break;
if (tCount++ > concurrencyCount)
{
break;
}
}
}
}
}
// 미사일이 발사될때마다 미사일을 메모리풀로 돌려보내는 것을 체크한다.
for (int i = 0; i < MissileArraySize; i++)
{
// 만약 미사일[i]가 활성화 되어있다면
if (MissileArray != null && MissileArray[i])
{
// 미사일[i]의 Collider2D가 비활성 되었다면
if (MissileArray[i].GetComponent <Collider2D>().enabled == false)
{
// 다시 Collider2D를 활성화 시키고
MissileArray[i].GetComponent <Collider2D>().enabled = true;
// 미사일을 메모리로 돌려보내고
MPool.RemoveItem(MissileArray[i]);
// 가리키는 배열의 해당 항목도 null(값 없음)로 만든다.
MissileArray[i] = null;
}
}
}
}
private void BossFire() // 파이어볼을 발사하는 함수
{
// 제어변수가 true일때만 발동
if (FireState)
{
StartCoroutine(FireCycleControl()); // 코루틴 "FireCycleControl"이 실행되며
for (int i = 0; i < FireBallMaxPool; i++) // 파이어볼 풀에서 발사되지 않은 파이어볼을 찾아서 발사
{
if (FireBallArray[i] == null) // 만약 화살배열[i]가 비어있다면
{
FireBallArray[i] = FireBallMPool.NewItem(); // 메모리풀에서 파이어볼을 가져옴
FireBallArray[i].transform.position = FireBallLocation.transform.position; // 해당 파이어볼의 위치를 파이어볼 발사지점으로 맞춤
FireBallArray[i].GetComponent <FireBallMove>().dir = transform.right; // X축 기준으로 발사
GameObject.Find("Boss_3_FireBall").GetComponent <AudioSource>().Play();
/*
* if문 써서 보스 플래그기 왼쪽인지 오른쪽인지 보고 불꽃 방향 바꾸는 라인 추가
* if(플래그가 왼쪽이거나 디스트가 레프트)
* renderer.filpx = true;
* else if(플래그가 오른쪽이거나 디스트가 라이트)
* renderer.filpx = false;
* dc2.dist = "Left"; // 이거 사용하면됨.
* dc2.movementFlag = 0; // 이것도 사용하면됨.
* -------------
* 데몬의 y로테이션 값이 180일때 오른쪽을 봄
* 컴포넌로 로테이션 값을 불러와서 이프문에 넣는걸로
*
* if ((dc2.dist == "Left") || (dc2.movementFlag == 1))
* transform.localScale = new Vector3(-1, 1, 1);
*
* else if ((dc2.dist == "Right") || (dc2.movementFlag == 2))
* transform.localScale = new Vector3(1, 1, 1);
*
* GetComponent.trasnform.eularAngles
*/
break; // 발사 후에 for문을 바로 빠져나감
}
}
}
for (int i = 0; i < FireBallMaxPool; i++) // 파이어볼이 발사될때마다 파이어볼을 메모리풀로 돌려보내는 것을 체크
{
if (FireBallArray[i]) // 만약 파이어볼[i]가 활성화 되어있다면
{
if (FireBallArray[i].GetComponent <BoxCollider>().enabled == false) // 파이어볼[i]의 Collider가 비활성 되었다면
{
FireBallArray[i].GetComponent <BoxCollider>().enabled = true; // 다시 Collider를 활성화 시키고
FireBallMPool.RemoveItem(FireBallArray[i]); // 파이어볼을 메모리로 돌려보내고
FireBallArray[i] = null; // 가리키는 배열의 해당 항목도 null(값 없음)로 만듦
}
}
}
// 코루틴 함수
IEnumerator FireCycleControl()
{
FireState = false; // 처음에 FireState를 false로 만들고
yield return(new WaitForSeconds(FireDelay)); // FireDelay초 후에
FireState = true; // FireState를 true로 만든다.
}
}