using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class PlayerController : MonoBehaviour
{
    // Start is called before the first frame update
    void Start()
    {
        
    }

    // Update is called once per frame
    void Update()
    {
        
    }
}

using UnityEngine;

public class PlayerController : MonoBehaviour
{
    // 이동 속도를 설정하는 변수
    public float moveSpeed = 5.0f;
    
    // 점프 힘을 설정하는 변수
    public float jumpForce = 7.0f;
    
    // Rigidbody 컴포넌트를 저장할 변수
    private Rigidbody rb;
    
    // 땅에 있는지 체크하는 변수
    private bool isGrounded;
    
    void Start()
    {
        // Rigidbody 컴포넌트를 가져와서 저장
        rb = GetComponent<Rigidbody>();
    }
    
    void Update()
    {
        // 키보드 입력 받기
        float horizontal = Input.GetAxis("Horizontal"); // A/D 또는 ←/→
        float vertical = Input.GetAxis("Vertical");     // W/S 또는 ↑/↓
        
        // 이동 방향 계산
        Vector3 movement = new Vector3(horizontal, 0, vertical);
        
        // 실제로 이동시키기
        transform.Translate(movement * moveSpeed * Time.deltaTime);
        
        // 스페이스바를 누르고 땅에 있으면 점프
        if (Input.GetKeyDown(KeyCode.Space) && isGrounded)
        {
            rb.AddForce(Vector3.up * jumpForce, ForceMode.Impulse);
            isGrounded = false;
        }
    }
    
    // 충돌 감지 (땅에 닿았는지 체크)
    void OnCollisionEnter(Collision collision)
    {
        if (collision.gameObject.CompareTag("Ground"))
        {
            isGrounded = true;
        }
    }
}

// 변수 선언 예제
int playerHealth = 100;           // 플레이어 체력
float moveSpeed = 5.5f;           // 이동 속도 (f를 붙여야 함!)
double preciseValue = 3.14159265; // 정밀한 값
bool isAlive = true;              // 생존 여부
char grade = 'A';                 // 등급
string playerName = "Hero";       // 플레이어 이름

// 상수 선언 (값을 변경할 수 없음)
const int MAX_HEALTH = 100;
const float GRAVITY = -9.81f;

// Vector3 사용 예제
Vector3 position = new Vector3(0, 0, 0);        // 원점
Vector3 forward = Vector3.forward;              // (0, 0, 1) - 앞 방향
Vector3 up = Vector3.up;                        // (0, 1, 0) - 위 방향
Vector3 right = Vector3.right;                  // (1, 0, 0) - 오른쪽 방향

// 벡터 연산
Vector3 pointA = new Vector3(1, 2, 3);
Vector3 pointB = new Vector3(4, 5, 6);
Vector3 sum = pointA + pointB;                  // 벡터 덧셈
Vector3 scaled = pointA * 2;                    // 스칼라 곱
float distance = Vector3.Distance(pointA, pointB); // 거리 계산

// 실전 활용
transform.position = new Vector3(0, 5, 0);      // 오브젝트를 (0, 5, 0)으로 이동
transform.Translate(Vector3.forward * Time.deltaTime); // 앞으로 이동

// Quaternion 사용 예제
Quaternion rotation = Quaternion.identity;      // 회전 없음 (0, 0, 0)

// Euler 각도로 회전 생성 (도 단위)
Quaternion rot = Quaternion.Euler(0, 90, 0);   // Y축으로 90도 회전

// 두 방향 사이의 회전 계산
Vector3 targetDirection = target.position - transform.position;
Quaternion lookRotation = Quaternion.LookRotation(targetDirection);

// 부드러운 회전 (보간)
transform.rotation = Quaternion.Slerp(
    transform.rotation, 
    targetRotation, 
    Time.deltaTime * rotationSpeed
);

// Color 사용 예제
Color red = Color.red;                          // 빨강
Color custom = new Color(1.0f, 0.5f, 0.0f);    // 주황색 (RGB 0~1 범위)
Color transparent = new Color(1, 1, 1, 0.5f);  // 반투명 흰색

// 실전 활용
Renderer renderer = GetComponent<Renderer>();
renderer.material.color = Color.green;          // 오브젝트를 초록색으로

// if-else 문
int health = 50;

if (health > 75)
{
    Debug.Log("체력이 충분합니다!");
}
else if (health > 25)
{
    Debug.Log("체력이 절반 이하입니다.");
}
else
{
    Debug.Log("위험! 체력이 매우 낮습니다!");
}

// switch 문
string weaponType = "Sword";

switch (weaponType)
{
    case "Sword":
        damage = 10;
        break;
    case "Bow":
        damage = 8;
        break;
    case "Magic":
        damage = 15;
        break;
    default:
        damage = 5;
        break;
}

// 삼항 연산자 (간단한 조건문)
string status = (health > 0) ? "Alive" : "Dead";
int finalDamage = isCritical ? damage * 2 : damage;

// for 문 - 정해진 횟수만큼 반복
for (int i = 0; i < 10; i++)
{
    Debug.Log("반복 횟수: " + i);
}

// while 문 - 조건이 참인 동안 반복
int count = 0;
while (count < 5)
{
    Debug.Log("카운트: " + count);
    count++;
}

// foreach 문 - 컬렉션의 모든 요소 순회
GameObject[] enemies = GameObject.FindGameObjectsWithTag("Enemy");
foreach (GameObject enemy in enemies)
{
    Destroy(enemy); // 모든 적 제거
}

// 실전 예제: 여러 오브젝트에 같은 작업 적용
Transform[] children = GetComponentsInChildren<Transform>();
foreach (Transform child in children)
{
    child.localScale = Vector3.one * 2; // 모든 자식 오브젝트 크기 2배
}

// 배열 선언과 초기화
int[] scores = new int[5];              // 크기 5인 정수 배열
scores[0] = 100;                        // 첫 번째 요소에 값 할당
scores[1] = 95;

// 초기값과 함께 선언
string[] playerNames = { "Alice", "Bob", "Charlie" };
float[] distances = new float[] { 1.5f, 2.3f, 3.7f };

// 배열 순회
for (int i = 0; i < scores.Length; i++)
{
    Debug.Log("점수 " + i + ": " + scores[i]);
}

// 2차원 배열 (맵, 그리드 등에 유용)
int[,] map = new int[10, 10];           // 10x10 맵
map[0, 0] = 1;                          // (0, 0) 위치에 값 설정

// Unity에서 배열 활용
public GameObject[] enemies;            // Inspector에서 할당 가능
public Transform[] waypoints;           // 경로 지점들

using System.Collections.Generic; // List 사용을 위해 필요

// 리스트 선언
List<int> inventory = new List<int>();
List<GameObject> activeEnemies = new List<GameObject>();

// 요소 추가
inventory.Add(1);                       // 아이템 ID 1 추가
inventory.Add(5);
inventory.Add(3);

// 요소 제거
inventory.Remove(5);                    // 값 5 제거
inventory.RemoveAt(0);                  // 인덱스 0 제거

// 요소 접근
int firstItem = inventory[0];
int count = inventory.Count;            // 리스트 크기

// 검색
bool hasItem = inventory.Contains(3);   // 3이 있는지 확인
int index = inventory.IndexOf(3);       // 3의 인덱스 찾기

// 정렬
inventory.Sort();                       // 오름차순 정렬
inventory.Reverse();                    // 역순으로

// 모두 제거
inventory.Clear();

// 실전 예제: 적 관리 시스템
public class EnemyManager : MonoBehaviour
{
    private List<GameObject> enemies = new List<GameObject>();
    
    public void SpawnEnemy(GameObject enemyPrefab)
    {
        GameObject newEnemy = Instantiate(enemyPrefab);
        enemies.Add(newEnemy);
    }
    
    public void RemoveEnemy(GameObject enemy)
    {
        enemies.Remove(enemy);
        Destroy(enemy);
    }
    
    public void RemoveAllEnemies()
    {
        foreach (GameObject enemy in enemies)
        {
            Destroy(enemy);
        }
        enemies.Clear();
    }
}

// 기본 함수 (반환값 없음)
void SayHello()
{
    Debug.Log("Hello, Unity!");
}

// 매개변수가 있는 함수
void Greet(string name)
{
    Debug.Log("안녕하세요, " + name + "님!");
}

// 반환값이 있는 함수
int Add(int a, int b)
{
    return a + b;
}

// 여러 매개변수와 반환값
float CalculateDamage(float baseDamage, float multiplier, bool isCritical)
{
    float damage = baseDamage * multiplier;
    if (isCritical)
    {
        damage *= 2;
    }
    return damage;
}

// 함수 호출
void Start()
{
    SayHello();                                 // 출력: Hello, Unity!
    Greet("플레이어");                          // 출력: 안녕하세요, 플레이어님!
    
    int sum = Add(5, 3);                        // sum = 8
    float finalDamage = CalculateDamage(10, 1.5f, true); // 30
}

// 기본 매개변수 (선택적 매개변수)
void TakeDamage(int damage, bool showEffect = true)
{
    health -= damage;
    if (showEffect)
    {
        PlayHitEffect();
    }
}

// 호출 방법
TakeDamage(10);              // showEffect는 true (기본값)
TakeDamage(10, false);       // showEffect를 false로 지정

// ref 키워드 (참조로 전달)
void ModifyValue(ref int value)
{
    value = value * 2;
}

int number = 5;
ModifyValue(ref number);     // number는 이제 10

// out 키워드 (출력 매개변수)
bool TryGetComponent(out Rigidbody rb)
{
    rb = GetComponent<Rigidbody>();
    return rb != null;
}

// 사용 예
Rigidbody myRb;
if (TryGetComponent(out myRb))
{
    myRb.AddForce(Vector3.up * 10);
}

// 오버로딩 (같은 이름, 다른 매개변수)
void Attack()
{
    // 기본 공격
}

void Attack(GameObject target)
{
    // 특정 대상 공격
}

void Attack(GameObject target, int damage)
{
    // 특정 대상에게 특정 데미지
}

// 간단한 클래스 정의
public class Enemy
{
    // 필드 (멤버 변수)
    public string enemyName;
    public int health;
    public int attackPower;
    
    // 생성자 (객체를 만들 때 호출)
    public Enemy(string name, int hp, int attack)
    {
        enemyName = name;
        health = hp;
        attackPower = attack;
    }
    
    // 메서드 (멤버 함수)
    public void TakeDamage(int damage)
    {
        health -= damage;
        if (health <= 0)
        {
            Die();
        }
    }
    
    public void Attack(Player target)
    {
        target.TakeDamage(attackPower);
    }
    
    private void Die()
    {
        Debug.Log(enemyName + "이(가) 죽었습니다!");
    }
}

// 클래스 사용
Enemy goblin = new Enemy("고블린", 50, 10);
Enemy dragon = new Enemy("드래곤", 200, 50);

goblin.TakeDamage(30);  // 고블린이 30 데미지를 받음
dragon.Attack(player);  // 드래곤이 플레이어를 공격

public class Player
{
    // private 필드
    private int health;
    private int maxHealth = 100;
    
    // 프로퍼티 (get, set)
    public int Health
    {
        get { return health; }
        set 
        { 
            health = Mathf.Clamp(value, 0, maxHealth); // 0~100 범위로 제한
            UpdateHealthUI(); // UI 업데이트
        }
    }
    
    // 자동 프로퍼티 (간단한 경우)
    public string PlayerName { get; set; }
    
    // 읽기 전용 프로퍼티
    public int MaxHealth 
    { 
        get { return maxHealth; } 
    }
    
    // 계산된 프로퍼티
    public float HealthPercentage
    {
        get { return (float)health / maxHealth * 100; }
    }
    
    private void UpdateHealthUI()
    {
        // UI 업데이트 로직
    }
}

// 사용 예
Player player = new Player();
player.Health = 50;              // set 호출
int currentHP = player.Health;   // get 호출
player.Health = 150;             // 100으로 제한됨 (Clamp)

// 기본 클래스 (부모 클래스)
public class Character
{
    public string name;
    public int health;
    public int level;
    
    public virtual void Attack()
    {
        Debug.Log(name + "이(가) 공격합니다!");
    }
    
    public void TakeDamage(int damage)
    {
        health -= damage;
    }
}

// 파생 클래스 (자식 클래스)
public class Warrior : Character
{
    public int armor;
    
    // 메서드 오버라이딩 (재정의)
    public override void Attack()
    {
        Debug.Log(name + "이(가) 검으로 강력하게 공격합니다!");
    }
    
    // 새로운 메서드 추가
    public void DefensiveStance()
    {
        armor += 10;
        Debug.Log("방어 태세!");
    }
}

public class Mage : Character
{
    public int mana;
    
    public override void Attack()
    {
        if (mana >= 10)
        {
            Debug.Log(name + "이(가) 마법을 시전합니다!");
            mana -= 10;
        }
    }
    
    public void CastSpell(string spellName)
    {
        Debug.Log(name + "이(가) " + spellName + " 주문을 시전!");
    }
}

// 사용 예
Warrior warrior = new Warrior();
warrior.name = "전사";
warrior.health = 150;
warrior.armor = 50;
warrior.Attack();           // "전사이(가) 검으로 강력하게 공격합니다!"
warrior.DefensiveStance();  // Warrior만의 메서드

Mage mage = new Mage();
mage.name = "마법사";
mage.health = 80;
mage.mana = 100;
mage.Attack();              // "마법사이(가) 마법을 시전합니다!"
mage.CastSpell("파이어볼"); // Mage만의 메서드

using UnityEngine;

public class PlayerController : MonoBehaviour
{
    [Header("이동 설정")]
    public float moveSpeed = 5f;
    public float rotationSpeed = 720f;
    
    [Header("발사 설정")]
    public GameObject bulletPrefab;
    public Transform firePoint;
    public float fireRate = 0.5f;
    
    private float nextFireTime = 0f;
    private Rigidbody rb;
    
    void Start()
    {
        rb = GetComponent<Rigidbody>();
    }
    
    void Update()
    {
        HandleMovement();
        HandleRotation();
        HandleShooting();
    }
    
    void HandleMovement()
    {
        float horizontal = Input.GetAxis("Horizontal");
        float vertical = Input.GetAxis("Vertical");
        
        Vector3 movement = new Vector3(horizontal, 0, vertical);
        movement = movement.normalized * moveSpeed * Time.deltaTime;
        
        transform.Translate(movement, Space.World);
    }
    
    void HandleRotation()
    {
        // 마우스 위치로 회전
        Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
        RaycastHit hit;
        
        if (Physics.Raycast(ray, out hit))
        {
            Vector3 targetDirection = hit.point - transform.position;
            targetDirection.y = 0;
            
            if (targetDirection != Vector3.zero)
            {
                Quaternion targetRotation = Quaternion.LookRotation(targetDirection);
                transform.rotation = Quaternion.RotateTowards(
                    transform.rotation, 
                    targetRotation, 
                    rotationSpeed * Time.deltaTime
                );
            }
        }
    }
    
    void HandleShooting()
    {
        if (Input.GetButton("Fire1") && Time.time >= nextFireTime)
        {
            Shoot();
            nextFireTime = Time.time + fireRate;
        }
    }
    
    void Shoot()
    {
        if (bulletPrefab != null && firePoint != null)
        {
            Instantiate(bulletPrefab, firePoint.position, firePoint.rotation);
        }
    }
}

using UnityEngine;

public class Bullet : MonoBehaviour
{
    public float speed = 20f;
    public int damage = 10;
    public float lifetime = 3f;
    
    private Rigidbody rb;
    
    void Start()
    {
        rb = GetComponent<Rigidbody>();
        rb.velocity = transform.forward * speed;
        
        // 일정 시간 후 자동 파괴
        Destroy(gameObject, lifetime);
    }
    
    void OnCollisionEnter(Collision collision)
    {
        // 적과 충돌했는지 확인
        Enemy enemy = collision.gameObject.GetComponent<Enemy>();
        if (enemy != null)
        {
            enemy.TakeDamage(damage);
        }
        
        // 총알 파괴
        Destroy(gameObject);
    }
}

using UnityEngine;

public class Enemy : MonoBehaviour
{
    [Header("스탯")]
    public int maxHealth = 50;
    public int currentHealth;
    public float moveSpeed = 3f;
    public int damage = 10;
    
    [Header("AI 설정")]
    public float detectionRange = 10f;
    public float attackRange = 2f;
    public float attackCooldown = 1f;
    
    private Transform player;
    private float nextAttackTime = 0f;
    
    void Start()
    {
        currentHealth = maxHealth;
        player = GameObject.FindGameObjectWithTag("Player")?.transform;
    }
    
    void Update()
    {
        if (player == null) return;
        
        float distanceToPlayer = Vector3.Distance(transform.position, player.position);
        
        if (distanceToPlayer <= detectionRange)
        {
            if (distanceToPlayer > attackRange)
            {
                // 플레이어를 향해 이동
                MoveTowardsPlayer();
            }
            else
            {
                // 공격 범위 안에 있으면 공격
                if (Time.time >= nextAttackTime)
                {
                    AttackPlayer();
                    nextAttackTime = Time.time + attackCooldown;
                }
            }
        }
    }
    
    void MoveTowardsPlayer()
    {
        Vector3 direction = (player.position - transform.position).normalized;
        direction.y = 0; // 수평 이동만
        
        transform.position += direction * moveSpeed * Time.deltaTime;
        transform.LookAt(new Vector3(player.position.x, transform.position.y, player.position.z));
    }
    
    void AttackPlayer()
    {
        PlayerHealth playerHealth = player.GetComponent<PlayerHealth>();
        if (playerHealth != null)
        {
            playerHealth.TakeDamage(damage);
            Debug.Log("적이 플레이어를 공격!");
        }
    }
    
    public void TakeDamage(int damageAmount)
    {
        currentHealth -= damageAmount;
        Debug.Log("적이 " + damageAmount + " 데미지를 받음! 남은 체력: " + currentHealth);
        
        if (currentHealth <= 0)
        {
            Die();
        }
    }
    
    void Die()
    {
        Debug.Log("적이 죽었습니다!");
        // 여기에 죽음 이펙트, 점수 추가 등을 구현
        Destroy(gameObject);
    }
    
    // 디버그용 - Scene 뷰에서 범위 표시
    void OnDrawGizmosSelected()
    {
        Gizmos.color = Color.yellow;
        Gizmos.DrawWireSphere(transform.position, detectionRange);
        
        Gizmos.color = Color.red;
        Gizmos.DrawWireSphere(transform.position, attackRange);
    }
}

using UnityEngine;
using UnityEngine.UI;

public class PlayerHealth : MonoBehaviour
{
    public int maxHealth = 100;
    public int currentHealth;
    
    public Slider healthBar; // UI 체력바
    
    void Start()
    {
        currentHealth = maxHealth;
        UpdateHealthBar();
    }
    
    public void TakeDamage(int damage)
    {
        currentHealth -= damage;
        currentHealth = Mathf.Clamp(currentHealth, 0, maxHealth);
        
        Debug.Log("플레이어 체력: " + currentHealth + "/" + maxHealth);
        UpdateHealthBar();
        
        if (currentHealth <= 0)
        {
            Die();
        }
    }
    
    public void Heal(int amount)
    {
        currentHealth += amount;
        currentHealth = Mathf.Clamp(currentHealth, 0, maxHealth);
        UpdateHealthBar();
    }
    
    void UpdateHealthBar()
    {
        if (healthBar != null)
        {
            healthBar.value = (float)currentHealth / maxHealth;
        }
    }
    
    void Die()
    {
        Debug.Log("플레이어가 죽었습니다!");
        // 게임 오버 처리
        Time.timeScale = 0; // 게임 일시정지
    }
}

// ❌ 나쁜 예 - 매 프레임마다 컴포넌트 찾기
void Update()
{
    Rigidbody rb = GetComponent<Rigidbody>(); // 비효율적!
    rb.AddForce(Vector3.up);
}

// ✅ 좋은 예 - 한 번만 찾아서 캐싱
private Rigidbody rb;

void Start()
{
    rb = GetComponent<Rigidbody>(); // 한 번만 실행
}

void Update()
{
    rb.AddForce(Vector3.up); // 빠름!
}

// ❌ 나쁜 예 - 불필요한 연산
void Update()
{
    GameObject player = GameObject.Find("Player"); // 매우 느림!
    float distance = Vector3.Distance(transform.position, player.transform.position);
}

// ✅ 좋은 예 - 필요할 때만 연산
private Transform playerTransform;
private float checkInterval = 0.5f;
private float nextCheckTime = 0f;

void Start()
{
    playerTransform = GameObject.FindGameObjectWithTag("Player").transform;
}

void Update()
{
    if (Time.time >= nextCheckTime)
    {
        float distance = Vector3.Distance(transform.position, playerTransform.position);
        // 거리 체크 로직
        nextCheckTime = Time.time + checkInterval;
    }
}

using System.Collections.Generic;
using UnityEngine;

public class ObjectPool : MonoBehaviour
{
    public GameObject prefab;
    public int poolSize = 20;
    
    private Queue<GameObject> pool = new Queue<GameObject>();
    
    void Start()
    {
        // 미리 오브젝트 생성
        for (int i = 0; i < poolSize; i++)
        {
            GameObject obj = Instantiate(prefab);
            obj.SetActive(false);
            pool.Enqueue(obj);
        }
    }
    
    public GameObject GetObject()
    {
        if (pool.Count > 0)
        {
            GameObject obj = pool.Dequeue();
            obj.SetActive(true);
            return obj;
        }
        else
        {
            // 풀이 비었으면 새로 생성
            return Instantiate(prefab);
        }
    }
    
    public void ReturnObject(GameObject obj)
    {
        obj.SetActive(false);
        pool.Enqueue(obj);
    }
}

// 사용 예
public class BulletSpawner : MonoBehaviour
{
    public ObjectPool bulletPool;
    
    void Shoot()
    {
        GameObject bullet = bulletPool.GetObject();
        bullet.transform.position = firePoint.position;
        bullet.transform.rotation = firePoint.rotation;
        
        // 3초 후 풀로 반환
        StartCoroutine(ReturnAfterDelay(bullet, 3f));
    }
    
    IEnumerator ReturnAfterDelay(GameObject obj, float delay)
    {
        yield return new WaitForSeconds(delay);
        bulletPool.ReturnObject(obj);
    }
}