[프로토타입] 몬스터그룹이 본진 공격하기

몬스터그룹 이동시키기.unitypackage

using System.Collections;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
using UnityEngine.UI;
 
public class TestMonster : MonoBehaviour
{
    public int colCount, rowCount;
    public int fenceX, fenceY;
 
    public Vector2[] blockPos;
    public Vector2[] fencesPos;
    public Vector2[] characterPos;
 
    //private Vector2[] monsterSpanPos;
    private List<Vector2> monsterSpanPos = new List<Vector2>();
 
    public Button moveMonsterBtn;
    public Button CreateMonsterLeftSpanBtn;
    public Button CreateMonsterRightSpanBtn;
    public Button CreateMonsterBottomSpanBtn;
    public Button testBtn;
 
    public GameObject testBuildingBtn;
 
    public Text txtTimer;
    private float timer = 5f;
 
    private int col = 0, row = 0;
    private int tileWidth = 64;
    private int tileHeight = 32;
    
    private GameObject monster;
    private GameObject workman;
 
    private GameObject village;
    private GameObject fence;
 
    private GameObject mapTile;
    private Coroutine routine;
    private Vector2 buildingPos;
 
    private Dictionary<Vector2, GameObject> dicTiles = new Dictionary<Vector2, GameObject>();
 
    public List<GameObject> characterList = new List<GameObject>();
    public List<GameObject> monsterList = new List<GameObject>();
 
    private GameObject motherNode;
    private GameObject villageNode;
    private GameObject selectedTile;
 
    private int testCnt1 = 0;
    private int testCnt2 = 0;
    
    private void Start()
    {
        this.CreateCharacter();
        this.CreateMap();
 
        this.ButtonManager();
 
        StartCoroutine(TouchMonsterSpanPos());
    }
 
    private IEnumerator TouchMonsterSpanPos()
    {
        while(true)
        {
            var ray = Camera.main.ScreenToWorldPoint(Input.mousePosition);
            RaycastHit2D hit = Physics2D.Raycast(ray, Vector2.zero);
 
            if (Input.GetMouseButtonDown(0))
            {
                if (hit.collider != null)
                {
                    this.monsterSpanPos.Add(hit.collider.GetComponent<TestTile>().vec2);
                }
            }
            yield return null;
        }
    }
 
    #region 버튼매니저
    private void ButtonManager()
    {
        this.moveMonsterBtn.onClick.AddListener(() =>
        {
            this.TestFindNodes();
        });
 
        this.testBtn.onClick.AddListener(() =>
        {
 
            //StartCoroutine(this.MonsterAttack());
        });
 
        #region 캐릭터생성버튼
        this.CreateMonsterLeftSpanBtn.onClick.AddListener(() =>
        {
            this.CreateLeftMonster();
        });
 
        this.CreateMonsterRightSpanBtn.onClick.AddListener(() =>
        {
            this.CreateRightMonster();
        });
 
        this.CreateMonsterBottomSpanBtn.onClick.AddListener(() =>
        {
            this.CreateBottomMonster();
        });
        #endregion
    }
    #endregion
 
    private void TestFindNodes()
    {
        foreach (var monster in this.monsterList)
        {
            var tile = this.dicTiles[monster.GetComponent<TestCharacter>().vec2];
 
            this.motherNode = tile;
 
            monster.GetComponent<TestCharacter>().openList = new List<GameObject>();
            monster.GetComponent<TestCharacter>().closeList = new List<GameObject>();
 
            if (this.FindeTargetNode(monster) == true)
            {
                StartCoroutine(this.FindNextPosImpl(monster));
            }
        }
    }
 
    private bool FindeTargetNode(GameObject monster)
    {
        if (villageNode != null)
        {
            while (true)
            {
                if (villageNode != motherNode)
                {
                    this.FindNode(monster);
                }
                else
                {
                    Debug.Log("길찾기 완료");
                    return true;
                }
            }
        }
        else
        {
            Debug.Log("어디로 가");
            return false;
        }
    }
 
    //길찾기
    #region 길찾기
 
    private void FindNode(GameObject monster)
    {
        var monsterScript = monster.GetComponent<TestCharacter>();
        var mother = motherNode.GetComponent<TestTile>().vec2;
 
        var motherX = mother.x - 1;
        var motherY = mother.y - 1;
        var maxX = mother.x + 1;
        var maxY = mother.y + 1;
 
        if (motherX < 0)
        {
            motherX = 0;
        }
        if (motherY < 0)
        {
            motherY = 0;
        }
 
        for (int x = (int)motherX; x <= maxX; x++)
        {
            for (int y = (int)motherY; y <= maxY; y++)
            {
                if (x < this.colCount && y < this.rowCount)
                {
                    var data = new Vector2(x, y);
 
                    var tile = this.dicTiles[data];
 
                    if (tile.GetComponent<TestTile>().isBlock != true && !monsterScript.closeList.Contains(tile))
                    {
                        if (data.x == motherX && data.y == mother.y || data.y == mother.y)
                        {
                            monsterScript.openList.Add(tile);
                            this.SetFGH(tile, motherNode);
                        }
                        if (data.y == motherY && data.x == mother.x || data.x == mother.x)
                        {
                            monsterScript.openList.Add(tile);
                            this.SetFGH(tile, motherNode);
                        }
 
                        monsterScript.openList.Remove(motherNode);
                        monsterScript.closeList.Add(motherNode);
                    }
                }
            }
        }
 
        if (motherNode.GetComponent<TestTile>().isFence)
        {
            motherNode.GetComponent<TestTile>().capacity--;
 
            if (motherNode.GetComponent<TestTile>().capacity <= 0)
            {
                motherNode.GetComponent<TestTile>().isBlock = true;
            }
            //TODO
        }
 
        IEnumerable<GameObject> sortNode = monsterScript.openList.OrderBy(x => x.GetComponent<TestTile>().f);
 
        this.selectedTile = sortNode.FirstOrDefault<GameObject>();
        this.motherNode = this.selectedTile;
 
        monsterScript.closeList.Add(motherNode);
    }
    #endregion
 
    #region 이동하기
    private IEnumerator FindNextPosImpl(GameObject testMonster)
    {
        var monster = testMonster.GetComponent<TestCharacter>();
 
        for (int i = 0; i < monster.closeList.Count; i++)
        {
            testMonster.GetComponent<Animator>().Play("run");
 
            while (true)
            {
                var dir = (monster.closeList[i].transform.position - testMonster.transform.position).normalized;
 
                var nextNode = Vector2.Distance(testMonster.transform.position, monster.closeList[i].transform.position);
 
                testMonster.transform.position += dir * monster.speed * Time.deltaTime;
 
                if (nextNode <= 0.03f)
                {
                    break;
                }
 
                yield return null;
            }
 
            if (i + 1 < monster.closeList.Count)
            {
                if (monster.closeList[i + 1].GetComponent<TestTile>().isFence == true || monster.closeList[i + 1].GetComponent<TestTile>().isBuilding == true)
                {
                    monster.closeList[i + 1].GetComponent<TestTile>().capacity--;
 
                    testMonster.GetComponent<Animator>().Play("attack");
 
                    //TODO
 
                    break;
                }
            }
 
            var distance = Vector2.Distance(testMonster.transform.position, this.villageNode.transform.position);
 
            if (distance <= 0.04f)
            {
                testMonster.GetComponent<TestCharacter>().vec2 = this.villageNode.GetComponent<TestTile>().vec2;
 
                testMonster.GetComponent<Animator>().Play("idle");
 
                Debug.Log("도착");
                break;
            }
        }
 
        yield return new WaitForSeconds(0.6f);
 
        testMonster.GetComponent<Animator>().Play("idle");
 
        //TODO
    }
    #endregion
 
    #region 타일초기화
    private void ClearMap()
    {
        for (int i = 0; i < colCount; i++)
        {
            for (int j = 0; j < rowCount; j++)
            {
                var tiles = new Vector2(j, i);
 
                var tile = dicTiles[tiles];
 
                if (!tile.GetComponent<TestTile>().isBlock || tile.GetComponent<TestTile>().isFence)
                {
                    tile.GetComponent<SpriteRenderer>().color = Color.white;
                }
            }
        }
    }
    #endregion
 
    #region FGH 입력하기
    private void SetFGH(GameObject tile, GameObject character)
    {
        var tileScript = tile.GetComponent<TestTile>();
 
        var getG = tile.GetComponent<TestTile>().g;
        var getH = tile.GetComponent<TestTile>().h;
        getG = Mathf.Round(Vector2.Distance(tile.GetComponent<TestTile>().vec2, character.GetComponent<TestTile>().vec2) * 10);
        var dx = Mathf.Abs(tile.GetComponent<TestTile>().vec2.x - this.village.GetComponent<TestTile>().vec2.x);
        var dy = Mathf.Abs(tile.GetComponent<TestTile>().vec2.y - this.village.GetComponent<TestTile>().vec2.y);
 
        getH = (dx + dy) * 10;
 
        tile.GetComponent<TestTile>().f = getG + getH;
 
        tileScript.G.text = getG.ToString();
        tileScript.H.text = getH.ToString();
        tileScript.F.text = tile.GetComponent<TestTile>().f.ToString();
    }
    #endregion
 
    #region 몬스터 생성
    private void CreateLeftMonster()
    {
        for (int i = 0; i < 5; i++)
        {
            this.monster = Instantiate(Resources.Load<GameObject>("Prefabs/monster"));
 
            var data = new Vector2(this.monsterSpanPos[2].x, this.monsterSpanPos[2].y);
 
            var leftMonsterPos = this.dicTiles[data];
 
            this.monster.AddComponent<TestCharacter>();
            this.monster.GetComponent<TestCharacter>().vec2 = leftMonsterPos.GetComponent<TestTile>().vec2;
 
            monster.transform.position = leftMonsterPos.transform.position;
 
            this.monsterList.Add(monster);
        }
    }
    private void CreateRightMonster()
    {
        for (int i = 0; i < 5; i++)
        {
            this.monster = Instantiate(Resources.Load<GameObject>("Prefabs/monster"));
 
            var data = new Vector2(this.monsterSpanPos[1].x, this.monsterSpanPos[1].y);
 
            var rightMonsterPos = this.dicTiles[data];
 
            this.monster.AddComponent<TestCharacter>();
            this.monster.GetComponent<TestCharacter>().vec2 = rightMonsterPos.GetComponent<TestTile>().vec2;
 
            monster.transform.position = rightMonsterPos.transform.position;
 
            this.monsterList.Add(monster);
        }
    }
    private void CreateBottomMonster()
    {
        for (int i = 0; i < 5; i++)
        {
            this.monster = Instantiate(Resources.Load<GameObject>("Prefabs/monster"));
 
            var data = new Vector2(this.monsterSpanPos[0].x, this.monsterSpanPos[0].y);
 
            var BottomMonsterPos = this.dicTiles[data];
 
            this.monster.AddComponent<TestCharacter>();
            this.monster.GetComponent<TestCharacter>().vec2 = BottomMonsterPos.GetComponent<TestTile>().vec2;
 
            monster.transform.position = BottomMonsterPos.transform.position;
 
            this.monsterList.Add(monster);
        }
    }
    #endregion
 
    #region 맵, 타일, 캐릭터 생성
    //캐릭터 생성입력
    private void CreateCharacter()
    {
        foreach (var characterPos in this.characterPos)
        {
            this.workman = Instantiate(Resources.Load<GameObject>("Prefabs/hero"));
 
            this.CreatedCharacter(this.workman, characterPos.x, characterPos.y);
        }
    }
 
    //캐릭터생성
    private void CreatedCharacter(GameObject character, float x, float y)
    {
        var vec2 = new Vector2(x, y);
 
        character.AddComponent<TestCharacter>();
        character.GetComponent<TestCharacter>().vec2 = vec2;
 
        this.characterList.Add(character);
 
        var screen = this.MapToScreen(vec2);
 
        var screenPos = Camera.main.ScreenToWorldPoint(new Vector2(screen.x, screen.y));
 
        character.transform.position = new Vector3(screenPos.x, screenPos.y, 0);
    }
 
    //맵생성입력
    private void CreateMap()
    {
        this.village = Instantiate(Resources.Load<GameObject>("Prefabs/128x128building"));
        this.buildingPos = new Vector2(this.colCount / 2, this.rowCount / 2);
        this.CreatedMap(village, this.buildingPos.x, this.buildingPos.y);
 
 
        for (int i = 0; i < this.fencesPos.Length; i++)
        {
            this.fence = Instantiate(Resources.Load<GameObject>("Prefabs/fence"));
            this.CreatedMap(fence, this.fencesPos[i].x, this.fencesPos[i].y);
        }
 
        while (true)
        {
            this.mapTile = Instantiate(Resources.Load<GameObject>("Prefabs/tile"));
 
            this.mapTile.tag = "Tile";
 
            this.mapTile.transform.SetParent(this.transform);
 
            this.CreatedMap(this.mapTile, this.col, this.row);
 
            this.dicTiles.Add(new Vector2(col, row), mapTile);
            this.col++;
 
            if (this.col >= this.colCount)
            {
                this.col = 0;
                this.row++;
            }
 
            if (this.row >= this.rowCount)
            {
                row = 0;
                this.WorldToCenterCamera();
                break;
            }
        }
    }
 
    //맵생성
    private void CreatedMap(GameObject tileMap, float x, float y)
    {
        var vec2 = new Vector2(x, y);
 
        tileMap.AddComponent<TestTile>();
        tileMap.GetComponent<TestTile>().vec2 = vec2;
 
        if (tileMap.GetComponent<TestTile>().vec2 == this.buildingPos)
        {
            tileMap.GetComponent<TestTile>().isBuilding = true;
            this.villageNode = tileMap;
        }
 
        for (int a = 0; a < this.blockPos.Length; a++)
        {
            if (vec2 == this.blockPos[a])
            {
                tileMap.name = "block";
                tileMap.GetComponent<SpriteRenderer>().color = Color.red;
                tileMap.GetComponent<TestTile>().isBlock = true;
            }
        }
 
        for (int b = 0; b < this.fencesPos.Length; b++)
        {
            if (vec2 == this.fencesPos[b])
            {
                tileMap.name = "fence";
                tileMap.GetComponent<TestTile>().isFence = true;
                tileMap.GetComponent<TestTile>().capacity = 3;
            }
        }
 
        var screen = this.MapToScreen(vec2);
 
        var screenPos = Camera.main.ScreenToWorldPoint(new Vector2(screen.x, screen.y));
 
        tileMap.transform.position = new Vector3(screenPos.x, screenPos.y, 0);
    }
 
    //맵포지를 스크린포지로
    public Vector2 MapToScreen(Vector2 mapPos)
    {
        var screenX = mapPos.x * this.tileWidth - (mapPos.y * this.tileWidth);
        var screenY = mapPos.y * -tileHeight - (mapPos.x * tileHeight);
 
        return new Vector2(screenX, screenY);
    }
 
    //카메라를 타일의 센터로
    private void WorldToCenterCamera()
    {
        var pos = new Vector2(this.colCount / 2 - 1, this.rowCount / 2 - 1);
 
        var posX = this.dicTiles[pos].transform.position.x;
        var posY = this.dicTiles[pos].transform.position.y;
 
        Camera.main.transform.localPosition = new Vector3(posX, posY, -100);
        Camera.main.orthographicSize = this.rowCount / 2;
    }
    #endregion
}