์ ๋ ๋จน๊ณ ๊ธ์ฐ๋๋ผ ์กฐ๊ธ ๋ฆ์์.
์๋์ ๋ณด์ ์ ๋๋ฉ์ด์ ๊ถ๊ธํดํ๋ ๋ถ์ด ์์ด์ ์ฌ๋ฆผ
1.์๋๋ ํํฐํด ์ฐ๋ ค๊ณ ํ์๊ณ , ์จ ๋ดค๋๋ฐ, ์ ๋ํฐ์์๋ ํํฐํด ์ ์ ํ๋ํ๋๋ฅผ ์ฝ๋๋ก ์กฐ์ ํ๋ ๊ถํ์ด ๊ต์ฅํ ๋ง์ด ์ ํ๋์ด ์์.
๋ณด์์ ๋ค์๊ณผ ๊ฐ์ ์ ๋๋ฉ์ด์ ์ผ๋ก ๋จน๋๋ก ํ๊ณ ์ถ์๋๋ฐ
์์ ๊ฐ์ด ํฉ๋ฟ๋ ค์ง ํ ์ ์ ๋ฉ์ถ๊ณ , ํ๋ ์ด์ด์๊ฒ ํํฐํด ์ ์ ํ๋์ฉ ์์์ฒ๋ผ ๋ฌ๋ผ๋ถ๋๋ก ํ๋ ค๋ ์ข...๋ง์ด ๊ทธ์ง๊ฐ์์.ย
์ ๋ํฐ์์ ํํฐํด ์์ ์๋ ์๋, ๋ฐฉํฅ, ๊ธฐํ ๋ฑ๋ฑ ์จ๊ฐ ๋ชจ๋๋ค์ ์ ๊ทผ์ด ๋ถ๊ฐ๋ฅํ๋๋ก ๊ตฌ์กฐ๊ฐ ๋์ด ์์ด์ย
๊ฒฐ๊ตญ ํฌ๊ธฐํ๊ณ ๋ณด์ ์ ์ ํ๋ฆฌํน์ ๋ง๋ค์ด์ ์ง์ ์ดํํธ๋ฅผ ๋ฟ๋๋ก ํด๋ฒ๋ ธ์.
2. ์ ๋๋ฉ์ด์ ์์๋ฅผ ๊ธ๋ก ๋ฌ์ฌํ๋ฉด
A.ํํฐํด์ด ์ํ์ผ๋ก ๋ฟ์ด์ ธ ๋์จ๋ค
B.์ผ์ radius์ ๋๋ฌํ ์ ์๋ ์์ํ ๋ฉ์ถ๋ค.
C.๋ณด์์ด ํ๋ ์ด์ด๋ฅผ ๋ฐ๋ผ๊ฐ๋ค.
D.ํ๋ ์ด์ด์ ๋ถ๋ชํ๋ฉด ๋ณด์์ ๋จน๋๋ค
๊ฐ ๋ ํ ๊ณ , ์ด๋ ๊ฒ ์์ฐจ์ ์ผ๋ก ์งํ๋๋ ์ ๋๋ฉ์ด์ ์ ๊ฒฝ์ฐ ์ฝ๋ฃจํด์ ์ด์ฉํ๋๊ฒ ํธํจ.
๊ทธ๋์ ๋ค์๊ณผ ๊ฐ์ ์ฝ๋๋ก ๋์๊ฐ
IEnumerator dropGems(int gemCount)
{
int bigGemCount = gemCount / GarlicGlobalSettings.GlobalSettings.bigGemHoldAmount;
int gemLeftCount = (gemCount - bigGemCount * GarlicGlobalSettings.GlobalSettings.bigGemHoldAmount);
int smallGemCount = gemLeftCount / GarlicGlobalSettings.GlobalSettings.smallGemHoldAmount;
ย
for(int i = 0; i < bigGemCount; i++)
{
gems.Add(spawnGem(burstCircleRadius, true));
}
for (int i = 0; i < smallGemCount; i++)
{
gems.Add(spawnGem(burstCircleRadius, false));
}
ย
effectBegun = true;
yield return new WaitForSeconds(pauseFirstBurstTime);
ย
stopAllChips();
ย
yield return new WaitForSeconds(pausingTime);
ย
//emitParticlesByVelocity(particleSystem, Vector2.zero);
ย
float deltaTime = 0;
while (deltaTime < chipFollowPlayerTimeLimit)
{
deltaTime += Time.deltaTime;
particlesFollowTarget(chipCollideTarget);
checkOverlap(chipCollideTarget);
yield return null;
}
ย
yield break;
}
->์์ดํ ์ Dropํ๋ ItemBurstManager๋ผ๋ ์คํฌ๋ฆฝํธ๊ฐ ์๊ณ , ์ฌ๊ธฐ์ ๋ด๊ฐ ๋ฟ์ด๋ด๊ณ ์ถ์ gem์ ๊ฐ์(gemCount)๋ฅผ ๋ฐ์ ๋ณด์์ ํฉ๋ฟ๋ฆฌ๋ ์ฝ๋.
spawnGem()์ ํธ์ถํ๋ฉด์ ๊ฐ Gem Object์ ๋ํด, ์ด๊ธฐํ์ ๋๋คํ๊ฒ ๋ฐฉํฅ๊ณผ ์๋๋ฅผ ์ค์ ํ๋๋ก ๊ตฌํํ์. ๊ทธ๋์ ๋ค์๊ณผ ๊ฐ์ ์ฝ๋๊ฐ ๋จ.
GemInfo spawnGem(float radius, bool isBigGem)
{
float randomAngle = Random.Range(0, 360f);
float randomRadius = Random.Range(0, radius);
Vector2 vect = new Vector2(transform.position.x + randomRadius * Mathf.Cos(randomAngle * Mathf.Deg2Rad),ย
transform.position.y + randomRadius * Mathf.Sin(randomAngle * Mathf.Deg2Rad));
ย
GameObject obj = null;
if(isBigGem)
{
obj = ObjectPoolingManager.Instance.GetObject(gemBigPrefab.name);
}
else
{
obj = ObjectPoolingManager.Instance.GetObject(gemSmallPrefab.name);
}
obj.transform.position = new Vector3(vect.x, vect.y, transform.position.z);
//obj.GetComponent<Renderer>().material.color = burstColor;
ย
Vector2 burstDirection = (vect - (Vector2)transform.position).normalized;
float speed = Random.Range(burstSpeedMin, burstSpeedMax);
obj.GetComponent<ChipCustomPhysics>().currentVelocity = burstDirection * speed;
ย
return obj.GetComponent<GemInfo>();
}
vect ๊ตฌํ๋ ๋ก์ง์ด ์ด๋ ค์ ๋ณด์ผ ์ ์๋๋ฐ ๊ทธ๋ฅ ์ ์์์ Gem์ด ์คํฐ๋ ์์น๋ฅผ ๋๋คํ๊ฒ ๊ตฌํ๋ ๊ฒ ๋ฟ์. (๋์ค์ ์์๋๋ฐ ์ ๋ํฐ์์ Random.insideUnitCircle ์ด๋ผ๋ ์ข์ ๋ฐฉ๋ฒ์ด ์์๋ค...)
๊ทธ ์ดํ ์์ ์ค์ฌ(์ด ๊ฒฝ์ฐ์๋ gem ์ค๋ธ์ ํธ๋ฅผ ๊ฐ์ง๊ณ ์๋ ๋ถ๋ชจ ์ค๋ธ์ ํธ์ ์์น)์ ๋ฐ๋ฅธ burstDirection์ ๊ตฌํ๊ณ , ์๋ ์ค์ ํ ๋.
์นฉ์ ์๋์ ๋ฐ๋ผ ์์ง์ด๋ ๋ก์ง์ ์ปค์คํ ์ผ๋ก ๋ฌผ๋ฆฌ ์ฐ์ฐ์ ๊ตฌํํจ. ๋ง์ด ์ปค์คํ ๋ฌผ๋ฆฌ ์ฐ์ฐ์ด์ง ์กด๋ ์ฌ์. ์ด๊ฒ ์ ๋ถ์.
public class ChipCustomPhysics : MonoBehaviour
{
public Vector2 currentVelocity;
// Update is called once per frame
void Update ()
{
transform.position += (Vector3)(currentVelocity * Time.deltaTime);
}ย
}
๊ฑ velocity ์ค์ ํ๊ฑฐ์ ๋ฐ๋ผ deltatime ๊ณฑํด์ ์ด๋๊ฑฐ๋ฆฌ ๊ตฌํ๋ฉด ๋. ๊ณ ๋ฑํ๊ต ๋ฌผ๋ฆฌ ์๊ฐ์ ๋ฐฐ์ด s=vt ์์ง? v๋ currentVelocity๊ณ t๋ Time.deltaTime์.
3. ๋ค์ dropGems๋ก ๋์๊ฐ๋ฉด, ์ด๋ ๊ฒ ์นฉ์ด ๋ฟ์ด์ ธ ๋์ค๋ค๊ฐ pauseFirstBurstTime์ด ์ง๋๋ฉด stopAllChips()๋ฅผ ํธ์ถํด ์นฉ์ ์๋๋ฅผ ๋จ์ดํธ๋ฆผ. ๋๋ ์ด๋ ๊ฒ ํ์.
void stopAllChips()
{
foreach(GemInfo chip in gems)
{
if(chip != null)
{
chip.gameObject.GetComponent<ChipCustomPhysics>().currentVelocity *= 0.3f;
}
}ย
ย }
์๋๋ฅผ 0์ผ๋ก ์ค์ ํด๋ฒ๋ฆฌ๋ ์ข ๋ถ์์ฐ์ค๋ฝ๊ฒ ๋ฉ์ถ๋๋ผ๊ตฌ. ๊ทธ๋์ ๊ทธ๋ฅ ์๋์ 0.3 ๊ณฑํด์ ์ฒ์ฒํ ๊ฐ๋๋ก ๋ง๋ฌ.
๊ทธ๋ฆฌ๊ณ ๋ค์ pausingTime์ด ์ง๋๊ณ ๋๋ฉด ์นฉ๋ค์ด ํ๋ ์ด์ด๋ฅผ ๋ฐ๋ผ๋ค๋๊ธฐ ์์ํจ.ย
while๋ฌธ์ ๋๋ฉด์ particlesFollowTarget ํจ์์์ ํ๋ ์ด์ด๋ฅผ ๋ฐ๋ผ๋ค๋๊ณ , ๋ง์ฝ ํ๋ ์ด์ด์ ๊ฒน์น๋ฉด checkOverlap ๋ด์์ gem์ ํ๋ํ๋ฉด์ ์ฌ๋ผ์ง๋๋ก ๊ตฌํํ์.
4.particlesFollowTarget์ ๋ค์๊ณผ ๊ฐ์ด ๊ตฌํํ์
void particlesFollowTarget(GameObject target)
{
if(target == null)
{
return;
}
for (int i = 0; i < gems.Count; i++)
{
ChipCustomPhysics physics = gems[i].GetComponent<ChipCustomPhysics>();
ย
Vector2 particleToPlayerVector = (target.transform.position - gems[i].transform.position).normalized;
physics.currentVelocity += particleToPlayerVector * 5f;
physics.currentVelocity *= 0.9f;
}ย
ย }
์ข ๊ทผ๋ณธ์๋ ์ฝ๋์ธ๋ฐ, gem์์ ํ๋ ์ด์ด๊น์ง ๋ฐฉํฅ์ ๊ตฌํ ํ์ ํํฐํด ์ด๋ ์๋์์ ํ๋ ์ด์ด๊น์ง์ ๋ฐฉํฅ ๋ ธ๋ง๋ฒกํฐ(๊ธธ์ด๊ฐ 1์ธ ๋ฒกํฐ)๋ฅผ ๋ํ ํ ๊ธธ์ด๋ฅผ 0.9๋ฐฐ๋ก ์ค์.
์ด๊ฒ ๋ญ ์๋ฆฌ๋๋ฉด ์ด๊ฑฐ์
๋ฒกํฐ์ ํฉ์ ํํ์ฌ๋ณํ์ ๊ทธ๋ ค์ ์ถ๋ฐ์ ๋ง์ํธ ๊ผญ์น์ ๊น์ง์ ๋ฒกํฐ์ธ๊ฑธ ์ด์ฉํด์,ย
ํ๋ ์ด์ด์๊ฒ ์ง์ ์ผ๋ก ๊ฐ์ง ์๊ณ ์ด์ง 'ํ์ด์ ธ์' ๊ฐ๋ ๋๋์ ์ฃผ๋ฉด์ ์๋๊ฐ ๋๋ฌด ๋น ๋ฅด์ง ์๋๋ก 0.9๋ฅผ ๊ณฑํด์ค.
ํ์ด์ ธ์ ๊ฐ๋ ์ ๋๋ 5f๋ 0.9f ๋ฑ์ ๊ฐ์ ๊ณ์ ์กฐ์ ํ๋ฉด์ ์ค์ ํ ์ ์์ ๊ฑฐ์. ๋๋ ๊ฑ ์ ๋ ๊ฒ ํ๋๊ฒ ์ ์ผ ๋์๋ณด์ฌ์ 5๋ 0.9๋ฅผ ์ ํํ์.
๊ทธ๋ฆฌ๊ณ ๋ญ ๋ถ๋ชํ์ ๋ณด์ ํ๋ํ๋๊ฑด ์ฌ๊ฐํ ๊ฒน์น๋๊ฑฐ ์ฒดํฌ ๋ก์ง์ด๋ setActive(false)๊ฐ ์ ๋ถ๋๊น ์คํตํ๊ณ .
์ด์์
---------------------------------
ํ๋ฏธ ์๊ฐ๋ณด๋ค ๊ธ์ฐ๋๋ฐ ์๊ฐ์ด ๊ฑธ๋ฆฌ๋ค
ํน์ ์ค๋ช ์ด ์๋ชป๋๊ฑฐ๋ ์ด์ํ๊ฑฐ๋ 1๋ ๋ชฐ๋ฅด๊ฒ๋ค ํ๋ฉด ๋๊ธ ๋ฌ๋ฉด ์๋ ๋ด์์ ๋ต๋ณํด์ค.
์กฐ์ ๋ด์ฉ์ด๋ค์
์คํ ์ด์ง ํด๋ฆฌ์ด ํฐํธ๋ก ์ด๊ฑฐ์์? ์ด๋ฏธ์ง๋ก ํ๊ฑฐ ์๋?
์ด๋ฏธ์ง๋ก ํ๊ฑฐ ๋ง์์ฌ...๋๋นต์ฉ์ผ๋ก ๋ฃ์๊ฑฐ๋ผ์ ๋ฐ๊พธ๊ธด ํ ๊ฑด๋ฐ ๋น๋ถ๊ฐ์ ์ ๊ฑฐ ์ธ๊ฑฐ์ ์
ใณใณ ์ง๊ธ ๋ดฃ๋ค