김산나

using Photon.Pun;
using Photon.Realtime;
using UnityEngine;

public class PhotonManger : MonoBehaviourPunCallbacks
{
    [Header("Room Settings")]
    [SerializeField] private string roomName = "KatanaRoom";
    [SerializeField] private byte maxPlayers = 4;

    [Header("Player")]
    [SerializeField] private string playerPrefabName = "Player"; // Resources 폴더 내 프리팹 이름
    [SerializeField] private Transform spawnPoint;               // 없으면 원점 스폰

    void Start()
    {
        PhotonNetwork.ConnectUsingSettings();
    }

    // 마스터 서버 연결 완료 → 로비 입장
    public override void OnConnectedToMaster()
    {
        Debug.Log("마스터 서버 연결됨. 로비 입장 중...");
        PhotonNetwork.JoinLobby();
    }

    // 로비 입장 완료 → 방 참가 또는 생성
    public override void OnJoinedLobby()
    {
        Debug.Log("로비 입장 완료. 방 참가 시도...");
        RoomOptions options = new()
        {
            MaxPlayers = maxPlayers,
            IsOpen = true,
            IsVisible = true
        };
        PhotonNetwork.JoinOrCreateRoom(roomName, options, TypedLobby.Default);
    }

    // 방 입장 완료 → 캐릭터 스폰
    public override void OnJoinedRoom()
    {
        Debug.Log($"방 입장 완료. 플레이어 수: {PhotonNetwork.CurrentRoom.PlayerCount}");
        SpawnPlayer();
    }

    // 방 생성 실패 시 재시도
    public override void OnCreateRoomFailed(short returnCode, string message)
    {
        Debug.LogWarning($"방 생성 실패: {message}. 재참가 시도...");
        PhotonNetwork.JoinOrCreateRoom(roomName, new RoomOptions { MaxPlayers = maxPlayers }, TypedLobby.Default);
    }

    // 방 참가 실패 시 새 방 생성
    public override void OnJoinRoomFailed(short returnCode, string message)
    {
        Debug.LogWarning($"방 참가 실패: {message}. 새 방 생성 중...");
        PhotonNetwork.CreateRoom(roomName, new RoomOptions { MaxPlayers = maxPlayers });
    }

    // 다른 플레이어 입장 로그
    public override void OnPlayerEnteredRoom(Photon.Realtime.Player newPlayer)
    {
        Debug.Log($"{newPlayer.NickName} 입장. 현재 인원: {PhotonNetwork.CurrentRoom.PlayerCount}");
    }

    // 다른 플레이어 퇴장 로그
    public override void OnPlayerLeftRoom(Photon.Realtime.Player otherPlayer)
    {
        Debug.Log($"{otherPlayer.NickName} 퇴장. 현재 인원: {PhotonNetwork.CurrentRoom.PlayerCount}");
    }

    // 연결 끊김 처리
    public override void OnDisconnected(DisconnectCause cause)
    {
        Debug.LogWarning($"연결 끊김: {cause}. 재연결 시도...");
        PhotonNetwork.ConnectUsingSettings();
    }

    private void SpawnPlayer()
    {
        Vector3 pos = spawnPoint != null ? spawnPoint.position : Vector3.zero;
        Quaternion rot = spawnPoint != null ? spawnPoint.rotation : Quaternion.identity;
        PhotonNetwork.Instantiate(playerPrefabName, pos, rot);
    }
}

using Photon.Pun;
using UnityEngine;

public class Player : MonoBehaviourPun, IPunObservable
{
    [Header("Movement")]
    [SerializeField] private float walkSpeed = 3f;
    [SerializeField] private float runSpeed = 6f;
    [SerializeField] private float rotationSmoothTime = 0.1f;

    [Header("Animation")]
    [SerializeField] private float animationDampTime = 0.1f;

    [Header("Network Sync")]
    [SerializeField] private float positionLerpSpeed = 10f;
    [SerializeField] private float rotationLerpSpeed = 10f;

    private Animator animator;
    private Rigidbody rb;
    private Transform cameraTransform;

    private float vertical;
    private float horizontal;
    private bool isRunning;
    private float rotationVelocity;

    // 원격 플레이어 동기화용
    private Vector3 networkPosition;
    private Quaternion networkRotation;
    private float networkAnimSpeed;

    private static readonly int SpeedHash = Animator.StringToHash("Speed");

    void Awake()
    {
        animator = GetComponent<Animator>();
        rb = GetComponent<Rigidbody>();
        rb.freezeRotation = true;
        rb.interpolation = RigidbodyInterpolation.Interpolate;

        networkPosition = transform.position;
        networkRotation = transform.rotation;

        // 내 캐릭터만 카메라 사용, 원격 플레이어는 물리 비활성화
        if (photonView.IsMine)
        {
            cameraTransform = Camera.main.transform;
        }
        else
        {
            rb.isKinematic = true;
        }
    }

    void Update()
    {
        if (photonView.IsMine)
        {
            HandleInput();
        }
        else
        {
            // 원격 플레이어: 수신한 위치/회전으로 보간
            transform.SetPositionAndRotation(
                Vector3.Lerp(transform.position, networkPosition, Time.deltaTime * positionLerpSpeed),
                Quaternion.Lerp(transform.rotation, networkRotation, Time.deltaTime * rotationLerpSpeed)
            );
            animator.SetFloat(SpeedHash, networkAnimSpeed, animationDampTime, Time.deltaTime);
        }
    }

    void FixedUpdate()
    {
        if (!photonView.IsMine) return;

        Vector2 inputDir = new(horizontal, vertical);

        if (inputDir.sqrMagnitude < 0.01f)
        {
            rb.linearVelocity = new Vector3(0f, rb.linearVelocity.y, 0f);
            return;
        }

        // 카메라 기준 이동 방향 계산
        Vector3 camForward = Vector3.ProjectOnPlane(cameraTransform.forward, Vector3.up).normalized;
        Vector3 camRight = Vector3.ProjectOnPlane(cameraTransform.right, Vector3.up).normalized;
        Vector3 moveDir = (camForward * vertical + camRight * horizontal).normalized;

        // 이동 방향으로 캐릭터 부드럽게 회전
        float targetAngle = Mathf.Atan2(moveDir.x, moveDir.z) * Mathf.Rad2Deg;
        float smoothAngle = Mathf.SmoothDampAngle(transform.eulerAngles.y, targetAngle, ref rotationVelocity, rotationSmoothTime);
        rb.MoveRotation(Quaternion.Euler(0f, smoothAngle, 0f));

        // 이동
        float currentSpeed = isRunning ? runSpeed : walkSpeed;
        Vector3 velocity = moveDir * currentSpeed;
        rb.linearVelocity = new Vector3(velocity.x, rb.linearVelocity.y, velocity.z);
    }

    // Photon 직렬화: 위치/회전/애니메이션 동기화
    public void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
    {
        if (stream.IsWriting)
        {
            // 내 데이터를 전송
            stream.SendNext(transform.position);
            stream.SendNext(transform.rotation);
            stream.SendNext(animator.GetFloat(SpeedHash));
        }
        else
        {
            // 원격 데이터 수신
            networkPosition = (Vector3)stream.ReceiveNext();
            networkRotation = (Quaternion)stream.ReceiveNext();
            networkAnimSpeed = (float)stream.ReceiveNext();
        }
    }

    private void HandleInput()
    {
        vertical = Input.GetAxisRaw("Vertical");
        horizontal = Input.GetAxisRaw("Horizontal");
        isRunning = Input.GetKey(KeyCode.LeftShift);

        float animSpeed = 0f;
        if (vertical != 0f || horizontal != 0f)
            animSpeed = isRunning ? runSpeed : walkSpeed;
        animator.SetFloat(SpeedHash, animSpeed, animationDampTime, Time.deltaTime);
    }
}

using System.Collections.Generic;
using UnityEngine;

// EnemyController.cs — State Pattern의 Context
//
// ■ Session 8 EnemyFSM과의 핵심 차이
//   EnemyFSM:        switch (currentState) { case Idle: ... case Chase: ... }
//   EnemyController: currentState.Update(this);   ← 이게 전부!
//
// ■ 자료구조 활용
//   - Dictionary : 상태 이름 → Color 매핑 (세션6 복습)
//   - Stack      : 상태 전환 히스토리 (세션2 복습)
//   - Interface  : IEnemyState 다형성 (List<IEnemyState> 저장 가능)
public class EnemyController : MonoBehaviour
{
    // ── 상태 인스턴스 ──────────────────────────────────────────
    // 미리 생성해두고 재사용 (new 남발 방지)
    [HideInInspector] public IdleState   idleState   = new IdleState();
    [HideInInspector] public ChaseState  chaseState  = new ChaseState();
    [HideInInspector] public AttackState attackState = new AttackState();
    [HideInInspector] public FleeState   fleeState   = new FleeState();

    IEnemyState currentState;

    // ── Inspector 설정값 ───────────────────────────────────────
    [Header("플레이어 참조")]
    public Transform player;

    [Header("AI 설정")]
    public float chaseRange     = 5f;
    public float attackRange    = 1.5f;
    public float fleeDistance   = 7f;
    public float moveSpeed      = 3f;
    public float fleeSpeed      = 4f;

    [Header("HP")]
    public float maxHp          = 100f;
    public float hp             = 100f;
    public float lowHpThreshold = 30f;

    // ★ Dictionary: 상태 이름 → 색상 매핑 (세션6)
    Dictionary<string, Color> stateColors;

    // ★ Stack: 상태 전환 히스토리 (세션2)
    Stack<string> stateHistory = new Stack<string>();

    // 상태 전환 이벤트 — UI 테스트에서 구독
    public System.Action<string, string> onStateChanged;

    SpriteRenderer sr;

    void Start()
    {
        sr = GetComponent<SpriteRenderer>();
        hp = maxHp;

        // Dictionary 초기화
        stateColors = new Dictionary<string, Color>()
        {
            { "Idle",   Color.white },
            { "Chase",  Color.yellow },
            { "Attack", Color.red },
            { "Flee",   new Color(0.3f, 0.5f, 1f) },
            { "Patrol", new Color(0.5f, 1f, 0.5f) }
        };

        ChangeState(idleState);
    }

    void Update()
    {
        if (player == null || currentState == null) return;

        // ★★★ switch 없이 다형성으로! ★★★
        currentState.Update(this);
    }

    // ── 상태 전환 ──────────────────────────────────────────────
    public void ChangeState(IEnemyState newState)
    {
        if (currentState == newState) return;

        string oldName = currentState?.Name ?? "None";

        // ★ Stack에 이전 상태 기록
        if (currentState != null)
            stateHistory.Push(currentState.Name);

        currentState?.Exit(this);
        currentState = newState;
        currentState.Enter(this);

        onStateChanged?.Invoke(oldName, currentState.Name);
        Debug.Log($"[StatePattern] {oldName} → {currentState.Name}");
    }

    // ── 헬퍼 메서드 (상태 클래스에서 호출) ────────────────────
    public void SetColor(Color color)
    {
        if (sr != null) sr.color = color;
    }

    public void MoveToward(Vector3 target, float speed)
    {
        Vector2 dir = ((Vector2)target - (Vector2)transform.position).normalized;
        transform.position += (Vector3)(dir * speed * Time.deltaTime);
    }

    public float DistToPlayer()
    {
        if (player == null) return float.MaxValue;
        return Vector2.Distance(transform.position, player.position);
    }

    // ── HP 조작 ────────────────────────────────────────────────
    public void TakeDamage(float amount)
    {
        hp = Mathf.Max(0, hp - amount);
    }

    public void Heal(float amount)
    {
        hp = Mathf.Min(maxHp, hp + amount);
        if (currentState == fleeState && hp > lowHpThreshold)
            ChangeState(idleState);
    }

    // ── 외부 접근용 ────────────────────────────────────────────
    public string CurrentStateName    => currentState?.Name ?? "None";
    public Stack<string> GetStateHistory()           => stateHistory;
    public Dictionary<string, Color> GetStateColors() => stateColors;
}

using UnityEngine;

public class IdleState : IEnemyState
{
    public string Name => "Idle";

    public void Enter(EnemyController e)
    {
        e.SetColor(Color.white);
    }

    public void Update(EnemyController e)
    {
        // 플레이어가 추적 범위 안에 들어오면 Chase로 전환
        if (e.DistToPlayer() < e.chaseRange)
            e.ChangeState(e.chaseState);
    }

    public void Exit(EnemyController e) { }
}

// ─────────────────────────────────────────────
//  2. ChaseState — 추적 (노란색)
// ─────────────────────────────────────────────
public class ChaseState : IEnemyState
{
    public string Name => "Chase";

    public void Enter(EnemyController e)
    {
        e.SetColor(Color.yellow);
    }

    public void Update(EnemyController e)
    {
        // 플레이어를 향해 이동
        e.MoveToward(e.player.position, e.moveSpeed);

        if (e.DistToPlayer() < e.attackRange)
            e.ChangeState(e.attackState);          // 사정거리 → 공격
        else if (e.DistToPlayer() > e.chaseRange)
            e.ChangeState(e.idleState);            // 너무 멀면 → 대기
    }

    public void Exit(EnemyController e) { }
}

// ─────────────────────────────────────────────
//  3. AttackState — 공격 (빨간색)
// ─────────────────────────────────────────────
public class AttackState : IEnemyState
{
    public string Name => "Attack";

    public void Enter(EnemyController e)
    {
        e.SetColor(Color.red);
    }

    public void Update(EnemyController e)
    {
        if (e.hp <= e.lowHpThreshold)
            e.ChangeState(e.fleeState);            // HP 낮으면 → 도망
        else if (e.DistToPlayer() > e.attackRange)
            e.ChangeState(e.chaseState);           // 멀어지면 → 다시 추적
    }

    public void Exit(EnemyController e) { }
}

// ─────────────────────────────────────────────
//  4. FleeState — 도망 (하늘색)
// ─────────────────────────────────────────────
public class FleeState : IEnemyState
{
    public string Name => "Flee";

    public void Enter(EnemyController e)
    {
        e.SetColor(new Color(0.3f, 0.5f, 1f));
    }

    public void Update(EnemyController e)
    {
        // 플레이어 반대 방향으로 이동
        Vector2 fleeDir = ((Vector2)e.transform.position - (Vector2)e.player.position).normalized;
        e.transform.position += (Vector3)(fleeDir * e.fleeSpeed * Time.deltaTime);

        // 충분히 멀어지면 HP 회복 후 대기
        if (e.DistToPlayer() > e.fleeDistance)
        {
            e.hp = e.maxHp;
            e.ChangeState(e.idleState);
        }
    }

    public void Exit(EnemyController e) { }
}

// ─────────────────────────────────────────────
//  5. PatrolState — 순찰 (연두색) ★ OCP 시연용
//     기존 파일(IdleState~FleeState, EnemyController) 수정 없이 추가!
// ─────────────────────────────────────────────
public class PatrolState : IEnemyState
{
    public string Name => "Patrol";

    Vector2 startPos;
    float angle = 0f;
    const float patrolRadius = 3f;

    public void Enter(EnemyController e)
    {
        startPos = e.transform.position;   // 현재 위치를 순찰 중심으로
        angle = 0f;
        e.SetColor(new Color(0.5f, 1f, 0.5f));  // 연두색
    }

    public void Update(EnemyController e)
    {
        // 원형 순찰 (중심점 기준으로 빙글빙글)
        angle += e.moveSpeed * 0.5f * Time.deltaTime;
        Vector2 target = startPos + new Vector2(Mathf.Cos(angle), Mathf.Sin(angle)) * patrolRadius;
        e.MoveToward(target, e.moveSpeed * 0.7f);

        // 플레이어 발견 → 즉시 추적
        if (e.DistToPlayer() < e.chaseRange)
            e.ChangeState(e.chaseState);
    }

    public void Exit(EnemyController e) { }
}