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);
}
// Update is called once per frame
IEnumerator MobGen()
{
int num = 0;
bool check = false;
while (true)
{
if (Wave_Start)
{
if (num < Prefab_Count.Count)
{
if (myTime >= GenTime[num])
{
for (int i = 0; i < Prefab_Count[num]; ++i)
{
if (i % 3 == 0)
{
pool.NewItem(Position[0].transform.position);
}
if (i % 3 == 1)
{
pool.NewItem(Position[1].transform.position);
}
if (i % 3 == 2)
{
pool.NewItem(Position[2].transform.position);
}
}
if (!check)
{
StartCoroutine("MobDie");
check = true;
}
num++;
}
}
myTime++;
if (myTime >= 1200)
{
break;
}
else
{
yield return(new WaitForSeconds(1));
}
}
yield return(new WaitForSeconds(1));
}
}
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;
}
}
}
}
/* 미사일 발사 */
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;
}
}
}
}
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;
}
}
}
}
private void RhythmGameNoteCreate(RhythmGameNoteCreateMsg msg)
{
if (msg.isRigth)
{
for (int i = 0; i < 10; i++)
{
if (RightNote[i] == null)
{
RightNote[i] = memoryPoolRight.NewItem();
RightNote[i].transform.localPosition = Vector3.zero;
RightNote[i].transform.localScale = new Vector3(noteItem.transform.localScale.x, noteItem.transform.localScale.y, noteItem.transform.localScale.z);
RightNote[i].GetComponent <RhythmGameNote_Controller>().MoveStart(rightTarget.transform.position, true, i, msg.noteCount);
return;
}
}
}
else
{
for (int i = 0; i < 10; i++)
{
if (LeftNote[i] == null)
{
LeftNote[i] = memoryPoolLeft.NewItem();
LeftNote[i].transform.localPosition = Vector3.zero;
LeftNote[i].transform.localScale = new Vector3(noteItem.transform.localScale.x, noteItem.transform.localScale.y, noteItem.transform.localScale.z);
LeftNote[i].GetComponent <RhythmGameNote_Controller>().MoveStart(leftTarget.transform.position, false, i, msg.noteCount);
return;
}
}
}
}
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);
}
//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 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;
}
}
}
}
Tile CreateTile(Transform parent, Vector2 position, Color color, int order = 1)
{
var go = pool.NewItem();
go.transform.parent = parent;
go.transform.localPosition = position;
Tile tile = go.GetComponent <Tile>();
tile.color = color;
tile.sortingOrder = order;
return(tile);
}
// 미사일을 발사하는 함수
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);
}
void PerfectJump_Effect()
{
GameObject gameObject;
gameObject = pool.NewItem();
gameObject.transform.position = this.transform.position + new Vector3(0, 0f, -1);
if (this.name == "Player1")
{
gameObject.GetComponent <Animator>().Play("Perfect_Jump_Up");
}
}
// 미사일을 발사하는 함수
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;
}
}
}
}
// 적생성
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);
}
private IEnumerator AzuraControll()
{
Vector3 AttackPoint = (AzuraHands[0].transform.position + AzuraHands[1].transform.position) / 2;
AttackPoint += Camera.main.transform.forward * 0.1f;
bool instance = false;
float distance = 0.0f;
Vector3 AzuraScale = AzuraBallPrefab.transform.localScale;
while (flug)
{
if (!instance && (AzuraHands[0].GetTouch() || AzuraHands[1].GetTouch()))
{
instance = true;
for (int i = 0; i < AzuraBall.Length; ++i)
{
if (AzuraBall[i] == null)
{
AzuraBallNum = i;
AzuraBall[i] = Azurapool.NewItem();
Debug.Log(AzuraBall[AzuraBallNum]);
AzuraBall[i].transform.position = AttackPoint;
Rigidbody r = AzuraBall[i].GetComponent <Rigidbody>();
r.useGravity = false;
r.velocity = new Vector3(0, 0, 0);
break;
}
//5발 다쏘고 난다음도 생각해야함
}
MyState.SetMyState(PlayerState.State.Charging, typecheck.Skills[0].GetSkillChargingTime());
}
else if (instance)
{
float handDis = Vector3.Distance(Hands[0].transform.position, Hands[1].transform.position);
if (handDis > distance)
{
distance = handDis;
Vector3 Azura = new Vector3(distance * 4.0f, distance * 4.0f, distance * 4.0f);
AzuraBall[AzuraBallNum].transform.localScale = Azura;
}
}
//yield return null;
yield return(new WaitForSeconds(0.03f));
}
}
public void SkillAttack()
{
animator.SetTrigger(hashAttack2);
m_emotion = MOTIONCHECK.E_SKILL;
if (PlayerPrefs.GetString("SelectCharacter") == "Yuko")
{
for (int i = 0; i < m_bullet.Length; i++)
{
if (m_bullet[i] == null)
{
m_bullet[i] = m_bulletpool.NewItem();
m_bullet[i].transform.position = new Vector3(this.transform.position.x, this.transform.position.y - 0.15f);
break;
}
}
}
}
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;
}
}
}
}
IEnumerator Generate()
{
GameObject infectee;
//for (int i = 0; i < generateNum; i++)
//{
// infectee = enemyPool.NewItem();
// if (infectee)
// {
// infectee.transform.position = new Vector3(Random.Range(-stage1_EnemyZone[0].rangeX, stage1_EnemyZone[0].rangeX), 1f, Random.Range(-stage1_EnemyZone[0].rangeY, stage1_EnemyZone[0].rangeY)) + stage1_EnemyZone[0].transform.position;
// infectee.transform.SetParent(parent);
// }
//}
if (stage_EnemyZone[0] == null)
{
stage_EnemyZone = GameObject.FindGameObjectsWithTag("SpawnZone");
}
for (int i = 0; i < stage_EnemyZone.Length; i++)
{
InfecteeZone stageEnemyZone = stage_EnemyZone[i].GetComponent <InfecteeZone>();
if (stageEnemyZone.spawnStage == PlayerManager.currentStage)
{
infectee = enemyPool.NewItem();
if (infectee)
{
infectee.transform.GetChild(0).position = new Vector3(Random.Range(-stageEnemyZone.rangeX + generateOffset, stageEnemyZone.rangeX - generateOffset), transform.position.y, Random.Range(-stageEnemyZone.rangeZ + generateOffset, stageEnemyZone.rangeZ - generateOffset)) + stageEnemyZone.transform.position + new Vector3(0, 0.4f, 0);
infectee.transform.SetParent(parent);
}
}
}
yield return(new WaitForSeconds(generateTime));
StartCoroutine(Generate());
}
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;
}
}
}
}
// Missile fire
void MissileFire()
{
if (GetComponent <Enemy_Info>().FireEnabled)
{
if (GetComponent <Enemy_Info>().FireState)
{
//Debug.Log("SemiPattern : " + SemiPattern);
//Debug.Log("Pattern : " + Pattern);
// 미사일 발사 속도 제어
StartCoroutine(FireCycleControl());
// 미사일 메모리풀에서 냠냠
for (int i = 0; i < Missile1Pool; i++)
{
if (Missile1[i] == null)
{
Missile1[i] = MPool1.NewItem();
Missile1[i].transform.position = MissileLocation1.transform.position;
break;
}
}
}
}
for (int i = 0; i < Missile1Pool; i++)
{
if (Missile1[i])
{
if (Missile1[i].GetComponent <Collider2D>().enabled == false)
{
Missile1[i].GetComponent <Collider2D>().enabled = true;
}
}
}
// Returns missiles in memory pool
}
// 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;
}
}
}
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));
}
}
IEnumerator TouchCheck()
{
while (true)
{
yield return(null);
if (Input.GetKeyDown(KeyCode.Mouse0))
{
Vector3 pos = Input.mousePosition;
pos = new Vector3(pos.x - offsetX, pos.y - offsetY, pos.z);
for (int i = 0; i < 10; i++)
{
if (TouchEffects[i] == null)
{
TouchEffects[i] = memoryPoolTouch.NewItem();
TouchEffects[i].transform.localPosition = pos;
TouchEffects[i].transform.localScale = TouchEffect.transform.localScale;
break;
}
}
}
}
}
// Missile fire
void MissileFire()
{
if (GetComponent <Enemy_Info>().FireEnabled)
{
if (GetComponent <Enemy_Info>().FireState)
{
// Boss1's missile pattern
switch (Pattern)
{
case 1:
{
Invoke("FireCycleControl", FireRateTime);
if (Missile1[0] == null && Missile1[1] == null && Missile1[2] == null && Missile1[3] == null)
{
for (int i = 0; i < 4; i++)
{
Missile1[i] = MPool1.NewItem();
}
Missile1[0].transform.position = MissileLocation1.transform.position;
Missile1[1].transform.position = MissileLocation2.transform.position;
Missile1[2].transform.position = MissileLocation3.transform.position;
Missile1[3].transform.position = MissileLocation4.transform.position;
}
GetComponent <Enemy_Info>().FireState = false;
break;
}
case 2:
{
Invoke("FireCycleControl", FireRateTime);
if (Missile1[4] == null && Missile1[5] == null && Missile1[6] == null && Missile1[7] == null)
{
for (int i = 4; i < 8; i++)
{
Missile1[i] = MPool1.NewItem();
}
Missile1[4].transform.position = MissileLocation1.transform.position;
Missile1[5].transform.position = MissileLocation2.transform.position;
Missile1[6].transform.position = MissileLocation3.transform.position;
Missile1[7].transform.position = MissileLocation4.transform.position;
}
GetComponent <Enemy_Info>().FireState = false;
break;
}
case 3:
{
Invoke("FireCycleControl", FireRateTime);
if (Missile2[0] == null && Missile2[1] == null)
{
for (int i = 0; i < 2; i++)
{
Missile2[i] = MPool2.NewItem();
}
Missile2[0].transform.position = MissileLocation1.transform.position;
Missile2[1].transform.position = MissileLocation4.transform.position;
}
GetComponent <Enemy_Info>().FireState = false;
break;
}
case 4:
{
Invoke("FireCycleControl", FireRateTime);
if (Missile3[0] == null && Missile3[1] == null)
{
for (int i = 0; i < 2; i++)
{
Missile3[i] = MPool3.NewItem();
}
Missile3[0].transform.position = MissileLocation2.transform.position;
Missile3[1].transform.position = MissileLocation3.transform.position;
}
GetComponent <Enemy_Info>().FireState = false;
break;
}
}
}
}
// Returns missiles in memory pool
for (int i = 0; i < MissileMaximumPool * 2; i++)
{
if (Missile1[i])
{
if (Missile1[i].GetComponent <Collider2D>().enabled == false)
{
Missile1[i].GetComponent <Collider2D>().enabled = true;
MPool1.RemoveItem(Missile1[i]);
Missile1[i] = null;
}
}
if (i < 2)
{
if (Missile2[i])
{
if (Missile2[i].GetComponent <Collider2D>().enabled == false)
{
Missile2[i].GetComponent <Collider2D>().enabled = true;
MPool2.RemoveItem(Missile2[i]);
Missile2[i] = null;
}
}
if (Missile3[i])
{
if (Missile3[i].GetComponent <Collider2D>().enabled == false)
{
Missile3[i].GetComponent <Collider2D>().enabled = true;
MPool3.RemoveItem(Missile3[i]);
Missile3[i] = null;
}
}
}
}
}
// 미사일을 발사하는 함수
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 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 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로 만든다.
}
}
