using System.Collections;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
using Newtonsoft.Json;
 
public class DataManager
{
    private static DataManager instance;
    private Dictionary<int, CharacterData> dicCharacterDatas;
 
 
    private DataManager()
    {
        this.dicCharacterDatas = new Dictionary<int, CharacterData>();
    }
 
    public DataManager GetInstance()
    {
        if (DataManager.instance == null)
        {
            DataManager.instance = new DataManager();
        }
        return DataManager.instance;
    }
 
    public void LoadData()
    {
        TextAsset textAsset = Resources.Load("data/character_data") as TextAsset;
        string json = textAsset.text;
        Debug.Log(json);
 
        CharacterData[] arrCharacterData = JsonConvert.DeserializeObject<CharacterData[]>(json);
 
        this.dicCharacterDatas = arrCharacterData.ToDictionary(x => x.id);
 
    }
 
    public CharacterData GetCharacterDataById(int id)
    {
        return this.dicCharacterDatas[id];
    }
 
 
}

> App.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
 
 
public class App : MonoBehaviour
{
    public Button btn;
    public GameObject heroPrefab;
    public GameObject weaponPrefab;
 
    private void Start()
    {
        this.btn.onClick.AddListener(() => {
            var heroModelGo = this.CreateModel();
            var weaponGo = this.CreateWeapon();
            var dummyRHand = heroModelGo.GetComponent<HeroModel>().dummyRHand;
            weaponGo.transform.SetParent(dummyRHand, false);
        });
    }
 
    private GameObject CreateModel()
    {
        return Instantiate(this.heroPrefab);
    }
    private GameObject CreateWeapon()
    {
        return Instantiate(this.weaponPrefab);
    }
 
}

>HeroModel.cs 

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
 
public class HeroModel : MonoBehaviour
{
 
    public Transform dummyRHand;
 
    // Start is called before the first frame update
    void Start()
    {
        
    }
 
    // Update is called once per frame
    void Update()
    {
        
    }
}

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
 
public class App : MonoBehaviour
{
    public Hero hero;
    public GameObject[] arrHeroModels;
    public string modelName;
 
    // Start is called before the first frame update
    void Start()
    {
      //  this.modelName = "";
        Debug.Log(this.modelName.ToString());
 
        this.hero.Init(this.CreateModel(this.modelName));
    }
 
    private GameObject CreateModel(string modelName)
    {
        GameObject foundModel = null;
        foreach (GameObject model in this.arrHeroModels)
        {
            if (model.name == modelName)
            {
                foundModel = model;
                break;
            }
        }
        Debug.LogFormat("model: {0}", foundModel);
 
        //게임오브젝트를 생성함 
        var newModel = UnityEngine.Object.Instantiate(foundModel);
        return newModel;
    }
}

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
 
public class Hero : MonoBehaviour
{
    public GameObject hero;
    // Start is called before the first frame update
    void Start()
    {
        
    }
 
    public void Init(GameObject newModel)
    {
        //newModel.transform.SetParent(this.transform);
        newModel.transform.SetParent(this.transform, false);
        Debug.Log("zzzz"); 
    }
    
}

public GameObject model;
public Button btn;
public int attackFrame;
 
private Animation anim;
private AnimationState state;
 
public int attackFrame;
private float totalFrames;
private float attackTime;
private float elapsedTimeAttack;  //타격 시간 
private float elapsedTimeAttackComplete;  //공격 애니메이션 종료 시간 
private bool isAttackAnimationPlaying;  //공격애니메이션 실행중인지 
private bool isAttack;  //공격을 했는지 
 
void Start()
{
    this.anim = this.model.GetComponent<Animation>();
    this.state = this.anim["attack_sword_01"];
    this.totalFrames = state.length * state.clip.frameRate;
    // fps의 뜻 (60fps, 30fps, 29.97fps, 24fps) 
    // 영상에서 매 초당 보여지는 이미지 장면의 수, 즉 프레임이 재생되는 속도
 
    // 22 : 8 = 0.733 : x 
    // 8 * 0.733 / 22 = x 
    this.attackTime =
        this.attackFrame * state.length / this.totalFrames;
 
}
 
void Update()
{
    //공격 애니메이션 실행 중이라면 
    if (this.isAttackAnimationPlaying)
    {
        //경과시간 누적 
        this.elapsedTimeAttack += Time.deltaTime;
        if (this.elapsedTimeAttack >= this.attackTime)
        {
            if (!this.isAttack)
            {
                //공격을 했는지 
                Debug.Log("타격!");
                this.isAttack = true;
            }
        }
 
        this.elapsedTimeAttackComplete += Time.deltaTime;
 
        if (this.elapsedTimeAttackComplete >= this.state.length)
        {
            //공격 애니메이션 종료 
            this.elapsedTimeAttack = 0;
            this.elapsedTimeAttackComplete = 0;
            this.isAttack = false;
            this.isAttackAnimationPlaying = false;
            this.anim.Play("idle@loop");
            Debug.Log("공격 애니메이션 종료");
        }
    }
}

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System;
using UnityEngine.UI;
 
public class App : MonoBehaviour
{
    public Animation anim;
    public Button btnMoveForward;
    public Button btnMoveBack;
    public Button btnMoveLeft;
    public Button btnMoveRight;
    public Button btnStop;
    public float speed;
 
    private bool isMove;
    private Vector3 dir;
 
 
    void Start()
    {
        this.btnMoveForward.onClick.AddListener(() => {
            this.Move(Vector3.forward);
        });
 
        this.btnMoveBack.onClick.AddListener(() => {
            this.Move(Vector3.back);
        });
 
        this.btnMoveRight.onClick.AddListener(() => {
            this.Move(Vector3.right);
        });
 
        this.btnMoveLeft.onClick.AddListener(() => {
            this.Move(Vector3.left);
        });
 
 
        this.btnStop.onClick.AddListener(() => {
            Debug.Log("Stop");
            this.Stop();
        });
    }
 
    private void Move(Vector3 dir) {
        this.dir = dir;
        this.anim.Play("run@loop");
        this.isMove = true;
    }
 
    private void Stop() {
        this.isMove = false;
        this.anim.Play("idle@loop");
    }
 
    private void Update()
    {
        if (this.isMove) {
            this.anim.gameObject.transform.Translate(this.dir * this.speed * Time.deltaTime);
        }
    }
}

* 방향, 속도, 시간

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System;
using UnityEngine.UI;
 
public class App : MonoBehaviour
{
    public GameObject model;
    public GameObject target;
    public Button btnMove;
 
    private bool isMove;
    private Animation anim;
 
    void Start()
    {
        this.anim = this.model.GetComponent<Animation>();
 
        this.btnMove.onClick.AddListener(() => {
            this.Move();
        });
    }
 
    private void Move() {
        this.isMove = true;
        this.anim.Play("run@loop");
    }
 
    private void Stop() {
        this.isMove = false;
        this.anim.Play("idle@loop");
    }
 
    private void Update()
    {
        if (this.isMove) {
            //float
            var distance = Vector3.Distance(model.transform.position,
                target.transform.position);
 
            //move
            var speed = 1.2f;
            var dir = Vector3.forward;
            this.model.transform.Translate(speed * dir * Time.deltaTime);
 
            Debug.Log(distance);
 
            if (distance <= 0.03f)
            {
                this.model.transform.position = this.target.transform.position;
                this.Stop();
            }
        }
 
    }
}

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System;
using UnityEngine.UI;
 
public class App : MonoBehaviour
{
    public GameObject model;
    public GameObject target;
    public Button btnMove;
    public float attackDely;
 
    private bool isMove;
    private bool isAttack;
    private Animation heroAnim;
    private Animation monsterAnim;
    private float elapsedTime;
    private int attackFrame;
    private float totalFrames;
    private float attackTime;
    private int attackCount;    //공격 몇번 했는지 카운트 
    private bool isImpact;   //타격 했나?
    private AnimationState attackAnimState;
    private bool isMonsterHit;
    private float monsterHitElapsedTime;
    private float monsterAttackDamageAnimLength;
    private float attackDelayElapsedTime;
    private bool isContinousAttack;
    private bool isMonsterDie;
    private float monsterDieElapsedTime;
    private float monsterDieAnimationLength;
 
 
    void Start()
    {
        //init
        this.attackFrame = 8;
        this.heroAnim = this.model.GetComponent<Animation>();
        this.monsterAnim = this.target.GetComponent<Animation>();
        this.monsterAttackDamageAnimLength = this.monsterAnim["Anim_Damage"].length;
        this.monsterDieAnimationLength = this.monsterAnim["Anim_Death"].length;
 
        this.attackAnimState = this.heroAnim["attack_sword_01"];
        this.totalFrames = this.attackAnimState.length * this.attackAnimState.clip.frameRate;
        //22 : 8 = 0.733 : x 
        // x = 8 * 0.733 / 22
        this.attackTime = this.attackFrame * this.attackAnimState.length / this.totalFrames;
 
        this.btnMove.onClick.AddListener(() => {
            this.Move();
        });
    }
 
    private void Move() {
        this.isMove = true;
        this.heroAnim.Play("run@loop");
    }
 
    private void Stop() {
        this.isMove = false;
        this.Idle();
    }
 
    private void Idle() {
        this.heroAnim.Play("idle@loop");
    }
 
    private void Attack() {
        this.isAttack = true;
        this.heroAnim.Play("attack_sword_01");
    }
 
    private void MonsterHit() {
        this.isMonsterHit = true;
        this.monsterAnim.Play("Anim_Damage");
    }
 
    private void MonsterIdle() {
        this.isMonsterHit = false;
        this.monsterAnim.Play("Anim_Idle");
    }
 
    private void Update()
    {
        if (this.isMove) {
            //float
            var distance = Vector3.Distance(model.transform.position,
                target.transform.position);
 
            //move
            var speed = 1.2f;
            var dir = Vector3.forward;
            this.model.transform.Translate(speed * dir * Time.deltaTime);
 
            if (distance <= 0.5f)
            {
                this.Stop();
                this.Attack();
            }
        }
 
        if (this.isAttack) {
 
            this.elapsedTime += Time.deltaTime;
            if (this.elapsedTime >= attackTime)
            {
                if (this.isImpact == false) {
                    isImpact = true;
                    this.MonsterHit();
                }
            }
 
            if (this.elapsedTime >= this.attackAnimState.length) {
                //공격 완료 
                this.isAttack = false;
                this.isImpact = false;
                this.elapsedTime = 0;
                this.attackCount++;
 
                Debug.Log(this.attackCount);
                
                this.Idle();
 
                if (this.attackCount >= 3) {
                    this.isContinousAttack = false;
                    this.MonsterDie();
                }
 
                
            }
        }
 
 
        if (this.isMonsterHit) {
            this.monsterHitElapsedTime += Time.deltaTime;
            if (this.monsterHitElapsedTime >= monsterAttackDamageAnimLength)
            {
                this.monsterHitElapsedTime = 0;
                this.MonsterIdle();
                this.isContinousAttack = true;
            }
        }
 
        if (this.isContinousAttack) {
            this.attackDelayElapsedTime += Time.deltaTime;
            if (this.attackDelayElapsedTime >= this.attackDely) {
                this.attackDelayElapsedTime = 0;
                this.isContinousAttack = false;
                this.Attack();
            }
        }
 
        if (this.isMonsterDie) {
            this.monsterDieElapsedTime += Time.deltaTime;
            if (this.monsterDieElapsedTime >= this.monsterDieAnimationLength) {
                UnityEngine.Object.Destroy(this.target.gameObject);
            }
        }
 
    }
 
    private void MonsterDie()
    {
        this.monsterAnim.Play("Anim_Death");
        this.isMonsterDie = true;
    }
}

public class App : MonoBehaviour
{
    //인스턴스가 로딩될때 한번만 호출됨 
    //게임오브젝트가 비활성화 일경우 호출 안됨 
    //게임오브젝트가 활성화 이고 컴포넌트가 비활성화 일경우 호출됨 
    private void Awake()
    {
        Debug.Log("App::Awake");
    }
 
    //게임오브젝트가 활성화 되었을경우 호출됨 
    //게임오브젝트가 비활성화 일경우 호출 안됨 
    //게임오브젝트가 활성화 이고 컴포넌트가 비활성화 일경우도 호출 안됨 
    private void OnEnable()
    {
        Debug.Log("App::OnEnable");
    }
 
    //오브젝트가 활성화 상태일경우 업데이트 함수 호출전에 한번만 호출됨 
    void Start()
    {
        Debug.Log("App::Start");
    }
 
    //오브젝트가 활성화 상태일경우 매프레임마다 호출됨 
    void Update()
    {
        Debug.Log("App::Update");
    }
 
    //오브젝트가 비활성화 일경우 호출됨 
    //인스턴스화 될때 게임오브젝트가 비활성화, 컴포넌트가 비활성일경우 호출안됨 
    //인스턴스화 되고 오브젝트또는 컴포넌트가 활성화에서 비활성화 되었을경우 호출됨 
    private void OnDisable()
    {
        Debug.Log("App::OnDisable");
    }
 
    //Object.Destroy 
    //씬 종료
    //오브젝트 존재의 마지막 프레임에 대해 모든 프레임 업데이트를 마친 후 이 함수가 호출됩니다. 
 
    //오브젝트 활성화, 컴포넌트 활성화 : 
    //Awake - OnEnable - Staret - Update - OnDisable - OnDestory 
 
    //오브젝트 활성화, 컴포넌트 비활성화 : 
    //Awake - OnDestory 
 
    //오브젝트 비활성화, 컴포넌트 활성화 : X 
 
 
    private void OnDestroy()
    {
        Debug.Log("App::OnDestroy");
    }
}

해설 코드

int initializeInMethod;
OutArgExample(out initializeInMethod);
Console.WriteLine(initializeInMethod);     // value is now 44
 
void OutArgExample(out int number)
{
    number = 44;
}

※ out 키워드를 사용하면 참조를 통해 인수를 전달할 수 있습니다.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
 
namespace _20200502
{
    public partial class form : Form
    {
        Random random;
 
        int[,] array;
        bool start = true;
        int totalScore;
 
        int x;
        int y;
        int randomNum1;
        int randomNum2;
 
        Control newNumTemp;
 
 
        public form()
        {
            InitializeComponent();
 
            this.Init();
            this.StartGame();
 
            this.TableInit();
 
            this.IsNumberBackgroundColor();
 
        }
 
        public void Init()
        {
            this.random = new Random();
            this.newNumTemp = new Control();
        }
 
        // up 버튼 입력시 해당 방향으로 재정렬
        public void UpDataSort()
        {
            int[,] newArr = new int[4, 4];
 
            for (int i = 0; i < 4; i++)
            {
                for (int j = 0; j < 4; j++)
                {
                    if (this.array[i, j] > 0)
                    {
                        for (int k = 0; k < newArr.GetLength(1); k++)
                        {
                            if (newArr[k, j] == 0)
                            {
                                if (k != 0)
                                {
                                    if (newArr[k - 1, j] == this.array[i, j])
                                    {
                                        newArr[k - 1, j] = this.array[i, j] * 2;
                                        this.totalScore += newArr[k - 1, j];
                                        break;
                                    }
                                }
                                newArr[k, j] = this.array[i, j];
                                break;
                            }
                        }
                    }
                }
            }
            this.array = newArr;
        }
 
        //ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ
 
        // down 버튼 입력시 해당 방향으로 재정렬
        public void DownDataSort()
        {
            int[,] newArr = new int[4, 4];
 
 
            for (int i = 3; i >= 0; i--)
            {
                for (int j = 3; j >= 0; j--)
                {
                    if (this.array[i, j] > 0)
                    {
                        for (int k = 3; k >= 0; k--)
                        {
                            if (newArr[k, j] == 0)
                            {
                                if (k != 3)
                                {
                                    if (newArr[k + 1, j] == this.array[i, j])
                                    {
                                        newArr[k + 1, j] = this.array[i, j] * 2;
                                        this.totalScore += newArr[k + 1, j];
                                        break;
                                    }
                                }
                                newArr[k, j] = this.array[i, j];
                                break;
                            }
                        }
                    }
                }
            }
            this.array = newArr;
        }
 
        //ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ
 
        // left 버튼 입력시 해당 방향으로 재정렬
        public void LeftDataSort()
        {
            int[,] newArr = new int[4, 4];
 
            for (int i = 0; i < 4; i++)
            {
                for (int j = 0; j < 4; j++)
                {
                    // 값있을 경우
                    if (this.array[j, i] > 0)
                    {
 
                        // 행 
                        for (int k = 0; k < newArr.GetLength(1); k++)
                        {
 
                            if (newArr[j, k] == 0)
                            {
                                if (k != 0)
                                {
                                    if (newArr[j, k - 1] == this.array[j, i])
                                    {
                                        newArr[j, k - 1] = this.array[j, i] * 2;
                                        this.totalScore += newArr[j, k - 1];
                                        break;
                                    }
                                }
                                newArr[j, k] = this.array[j, i];
                                break;
                            }
                        }
                    }
                }
            }
            this.array = newArr;
        }
 
        //ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ
 
        // right 버튼 입력시 해당 방향으로 재정렬
        public void RightDataSort()
        {
            int[,] newArr = new int[4, 4];
 
            for (int i = 3; i >= 0; i--)
            {
                for (int j = 0; j < 4; j++)
                {
                    // 값있을 경우
                    if (this.array[j, i] > 0)
                    {
                        // 행 
                        for (int k = 3; k >= 0; k--)
                        {
 
                            if (newArr[j, k] == 0)
                            {
                                if (k != 3)
                                {
                                    if (newArr[j, k + 1] == this.array[j, i])
                                    {
                                        newArr[j, k + 1] = this.array[j, i] * 2;
                                        this.totalScore += newArr[j, k + 1];
                                        break;
                                    }
                                }
                                newArr[j, k] = this.array[j, i];
                                break;
                            }
                        }
                    }
                }
            }
            this.array = newArr;
        }
 
        //ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ
 
        // 뷰테이블에 있는 데이터, 로직 배열과 동기화
        public void TableInit()
        {
            this.array = new int[4, 4];
 
            foreach (Control ctrl in tableLayoutPanel1.Controls)
            {
                if (ctrl is Label)
                {
                    var row = tableLayoutPanel1.GetRow(ctrl);
                    var col = tableLayoutPanel1.GetColumn(ctrl);
 
                    this.array[row, col] = 0;
 
                    // 값 있는 경우
                    if (ctrl.Text.Length > 0)
                    {
                        int myNum = int.Parse(ctrl.Text);
                        this.array[row, col] = myNum;
                    }
                }
            }
            this.IsNumberBackgroundColor();
        }
 
 
        // 뷰 라벨 테이블 비우고 데이터 배열 초기화
        public void NewTable()
        {
            foreach (Control ctrl in tableLayoutPanel1.Controls)
            {
                if (ctrl is Label)
                {
                    ctrl.Text = "";
                }
            }
            this.array = new int[4, 4];
        }
 
        // 게임 스타트시 초기값 발생
        public void StartGame()
        {
            this.RandomXY();
            this.RandomNum();
            tableLayoutPanel1.GetControlFromPosition(y, x).Text = randomNum2.ToString();
 
            this.RandomXY();
            this.RandomNum();
            tableLayoutPanel1.GetControlFromPosition(y, x).Text = randomNum1.ToString();
        }
 
        // 처음에 주어지는 숫자 위치 정하기
        public void RandomXY()
        {
            // 낮은 확률로 처음 주어지는 숫자 위치 중첩 방지
            while (true)
            {
                int tempX = random.Next(0, 4);
                int tempY = random.Next(0, 4);
 
                if (this.x != tempX && this.y != tempY)
                {
                    this.x = tempX;
                    this.y = tempY;
                    break;
                }
            }
        }
 
 
        // 처음에 주어지는 숫자 2,4 난수 발생 로직
        public void RandomNum()
        {
            while (true)
            {
                int tempNum1 = random.Next(2, 5);
                int tempNum2 = random.Next(2, 5);
 
                bool cheeck1 = false;
                bool cheeck2 = false;
 
                // 처음만 두개의 숫자 발생
                if (this.start)
                {
                    if (tempNum2 == 2 || tempNum2 == 4)
                    {
                        this.randomNum1 = tempNum2;
                        cheeck1 = true;
                    }
                }
 
                if (tempNum1 == 2 || tempNum1 == 4)
                {
                    this.randomNum2 = tempNum1;
                    cheeck2 = true;
                }
 
                if (cheeck1 && cheeck2)
                {
                    break;
                }
            }
 
        }
 
        // 턴 이후 지급되는 랜덤 숫자 생성
        public void CreateNewNum()
        {
            while (true)
            {
                this.RandomXY();
                if (this.array[this.x, this.y] == 0)
                {
                    break;
                }
            }
            this.newNumTemp.ForeColor = Color.Black;
            this.RandomNum();
            this.array[this.x, this.y] = this.randomNum2;
            tableLayoutPanel1.GetControlFromPosition(y, x).Text = this.randomNum2.ToString();
 
            tableLayoutPanel1.GetControlFromPosition(y, x).ForeColor = Color.IndianRed;
 
            this.newNumTemp = tableLayoutPanel1.GetControlFromPosition(y, x);
 
            logBox.Items.Add($"신규랜덤난수:[{x},{y}]:{this.randomNum2}");
        }
 
 
 
        // new버튼 이벤트 발생시 초기화
        public void GameReset()
        {
            this.array = new int[4, 4];
            this.start = true;
            this.totalScore = 0;
 
 
            this.ViewReset();
            this.StartGame();
            this.TableInit();
            this.SetScoreView();
        }
 
        // 전체 테이블 라벨 지우고, log창 지우기
        public void ViewReset()
        {
            foreach (Control ctrl in tableLayoutPanel1.Controls)
            {
                if (ctrl is Label)
                {
                    ctrl.Text = "";
                }
            }
            logBox.Items.Clear();
        }
 
        // sort된 배열, 뷰 테이블라벨에 재적용
        public void UpdateView()
        {
            foreach (Control ctrl in tableLayoutPanel1.Controls)
            {
                if (ctrl is Label)
                {
                    var row = tableLayoutPanel1.GetRow(ctrl);
                    var col = tableLayoutPanel1.GetColumn(ctrl);
                    ctrl.Text = "";
 
                    // 값 있는 경우
                    if (this.array[row, col] > 0)
                    {
                        ctrl.Text = this.array[row, col].ToString();
                    }
                }
            }
        }
 
        // 빈배열 있는지 체크
        public bool EndGameCheck()
        {
            foreach (var item in this.array)
            {
                if (item == 0)
                {
                    return true;
                }
            }
            return false;
        }
 
        // 게임 클리어 체크
        public bool ClearGameCheck()
        {
            foreach (var item in this.array)
            {
                if (item.Equals(2048))
                {
                    return true;
                }
            }
            return false;
        }
 
        // 연산값에 대한 뷰 컬러처리
        public void IsNumberBackgroundColor()
        {
            int checkNum = 0;
            foreach (Control ctrl in tableLayoutPanel1.Controls)
            {
                if (ctrl is Label)
                {
                    ctrl.BackColor = Color.Gainsboro;
 
                    if (ctrl.Text != "")
                    {
                        checkNum = int.Parse(ctrl.Text);
 
                        if (checkNum == 8)
                        {
                            ctrl.ForeColor = Color.WhiteSmoke;
                            ctrl.BackColor = Color.LightSalmon;
                        }
                        else if (checkNum == 16)
                        {
                            ctrl.ForeColor = Color.WhiteSmoke;
                            ctrl.BackColor = Color.LightCoral;
                        }
                        else if (checkNum == 32)
                        {
                            ctrl.ForeColor = Color.WhiteSmoke;
                            ctrl.BackColor = Color.Coral;
                        }
                        else if (checkNum >= 64)
                        {
                            ctrl.ForeColor = Color.WhiteSmoke;
                            ctrl.BackColor = Color.Tomato;
                        }
                        else
                        {
                            ctrl.BackColor = Color.Silver;
                            ctrl.ForeColor = Color.Black;
                        }
                    }
 
                    if (ctrl.Text == "")
                    {
                        ctrl.BackColor = Color.Silver;
                        ctrl.ForeColor = Color.Black;
                    }
                }
            }
        }
 
        // 스코어 뷰에 누계 적용
        public void SetScoreView()
        {
            scoreLabel.Text = this.totalScore.ToString();
        }
 
        // 개발시 배열 확인용 매소드
        public void ArrayPrint()
        {
            for (int i = 0; i < this.array.GetLength(0); i++)
            {
                for (int j = 0; j < this.array.GetLength(1); j++)
                {
                    Console.Write("[{0}, {1}]:{2} ㅣ", i, j, this.array[i, j]);
                }
                Console.WriteLine();
            }
            Console.WriteLine();
        }
 
        //ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ 방향킼 버튼 이벤트 리스너 ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ
        private void UpBtn_Click(object sender, EventArgs e)
        {
            if (ClearGameCheck()) { MessageBox.Show("게임 클리어!!"); }
            if (EndGameCheck())
            {
                this.UpDataSort();
                this.UpdateView();
                this.CreateNewNum();
                this.IsNumberBackgroundColor();
                this.SetScoreView();
            }
            else
            {
                MessageBox.Show("게임 종료");
            }
        }
 
        private void DownBtn_Click(object sender, EventArgs e)
        {
            if (ClearGameCheck()) { MessageBox.Show("게임 클리어!!"); }
            if (EndGameCheck())
            {
                this.DownDataSort();
                this.UpdateView();
                this.CreateNewNum();
                this.IsNumberBackgroundColor();
                this.SetScoreView();
            }
            else
            {
                MessageBox.Show("게임 종료");
            }
        }
 
        private void LeftBtn_Click(object sender, EventArgs e)
        {
            if (ClearGameCheck()) { MessageBox.Show("게임 클리어!!"); }
            if (EndGameCheck())
            {
                this.LeftDataSort();
                this.UpdateView();
                this.CreateNewNum();
                this.IsNumberBackgroundColor();
                this.SetScoreView();
            }
            else
            {
                MessageBox.Show("게임 종료");
            }
        }
 
        private void RightBtn_Click(object sender, EventArgs e)
        {
            if (ClearGameCheck()) { MessageBox.Show("게임 클리어!!"); }
            if (EndGameCheck())
            {
                this.RightDataSort();
                this.UpdateView();
                this.CreateNewNum();
                this.IsNumberBackgroundColor();
                this.SetScoreView();
            }
            else
            {
                MessageBox.Show("게임 종료");
            }
        }
 
        // ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ new 버튼  ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ
 
        // newGame 버튼 클릭시 비우고 난수 발생하기
        private void button1_Click(object sender, EventArgs e)
        {
            this.GameReset();
        }
 
        //ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ ?? ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ
        private void tableLayoutPanel1_Paint(object sender, PaintEventArgs e)
        {
 
        }
 
    }
}