[게임엔진활용] 11강 피하기 게임 제작

피하기 게임 제작

- 계속 피해서 적이 모이면, 적이 한곳에 모이는 현상 발생 => 해결책 과제로 제출

using UnityEngine;
using UnityEngine.InputSystem;
 
public class GameRog : RenderView
{
    class Enemy
    {
        public Vector2 p, v;
        public float speed;
 
        public Vector2 tP;
        public float aiDt;
    }
 
    class Hero
    {
        public Vector2 p, v;
        public float speed, stamina;
 
        public Vector2 fv;
        public float fRate, fSpeed;
    }
    Hero pHero;
 
    Enemy[] enemy;
    int enemyNum;
    float createEnemyDt;
 
    public override void load()
    {
        pHero = new Hero();
        pHero.p = new Vector2(mc.devWidth / 2, mc.devHeight / 2);
        pHero.v = new Vector2(0, 0);
        pHero.speed = 200;
        pHero.stamina = 100;
 
        enemy = new Enemy[100];
        enemyNum = 0;
        createEnemyDt = 0f;
    }
 
    public override void free()
    {
    }
 
    public override void draw(float dt)
    {
        // view
        setRGBA(0, 0, 0, 0.9f);
        fillRect(0, 0, mc.devWidth, mc.devHeight);
 
        setRGBA(1, 1, 1, 1);
        fillRect(pHero.p.x - 25, pHero.p.y - 25, 50, 50);
 
        setRGBA(1, 1, 0, 1);
        float w = 200 * pHero.stamina / 100;
        fillRect(50, 50, w, 5);
 
        setRGBA(1, 0, 0, 1);
        for (int i = 0; i < enemyNum; i++)
        {
            Enemy e = enemy[i];
            fillRect(e.p.x - 25, e.p.y - 25, 50, 50);
            // ai apply
            if (e.p != e.tP)
            {
                //e.p => e.tP; 이동
                Vector2 vector = e.tP - e.p;
                vector.Normalize();
 
                //e.p += vector * dt;
                Vector2 vt = vector * 200 * dt;
                if (e.p.x < e.tP.x)
                {
                    e.p.x += vt.x; if (e.p.x > e.tP.x) e.p.x = e.tP.x;
                }
                else if (e.p.x > e.tP.x)
                {
                    e.p.x += vt.x; if (e.p.x < e.tP.x) e.p.x = e.tP.x;
                }
                if (e.p.y < e.tP.y)
                {
                    e.p.y += vt.y; if (e.p.y > e.tP.y) e.p.y = e.tP.y;
                }
                else if (e.p.y > e.tP.y)
                {
                    e.p.y += vt.y; if (e.p.y < e.tP.y) e.p.y = e.tP.y;
                }
            }
            else
            {
                e.aiDt += dt;
                if (e.aiDt > 0.5f)
                {
                    e.aiDt = 0f;
                    e.tP = pHero.p;
                }
            }
 
            if ((pHero.p.x - e.p.x) * (pHero.p.x - e.p.x) +
                (pHero.p.y - e.p.y) * (pHero.p.y - e.p.y) < 50 * 50)
            {
                // hero dmg
                enemyNum--;
                enemy[i] = enemy[enemyNum];
                i--;
            }
        }
        setRGBA(1, 1, 1, 1);
 
        if (enemyNum < 100)
        {
            createEnemyDt += dt;
            if (createEnemyDt > 5.0f)
            {
                createEnemyDt -= 5.0f;
                Enemy e = new Enemy();
                e.p.x = getRandom() % mc.devWidth;
                e.p.y = getRandom() % mc.devHeight;
                e.tP = e.p;
 
                enemy[enemyNum] = e;
                enemyNum++;
            }
        }
 
        // ctrl
        Vector2 v = new Vector2(0, 0);
        if (Keyboard.current.wKey.isPressed) v.y = -1;
        if (Keyboard.current.sKey.isPressed) v.y = +1;
        if (Keyboard.current.aKey.isPressed) v.x = -1;
        if (Keyboard.current.dKey.isPressed) v.x = +1;
        v.Normalize();
 
        if (Keyboard.current.spaceKey.isPressed)
        {
            if (pHero.stamina > 0)
            {
                pHero.stamina -= 30 * Time.deltaTime;
                v *= 2;
            }
        }
        else
        {
            if (pHero.stamina < 100)
                pHero.stamina += 5 * Time.deltaTime;
        }
 
        pHero.p += v * pHero.speed * Time.deltaTime;
    }
 
    public override void mouse(int state, float x, float y)
    {
    }
}