열거형과 비트 플래그

// 숫자로 상태를 나타내는 예시
int difficulty = 2;      // 0: 쉬움, 1: 보통, 2: 어려움

if (difficulty == 2)
{
    Console.WriteLine("적의 체력이 두 배임");
}

difficulty = 7;          // 없는 난이도인데 아무 일도 일어나지 않음
Console.WriteLine($"난이도 {difficulty}");

// 열거형 사용 예시
Difficulty difficulty = Difficulty.Hard;

if (difficulty == Difficulty.Hard)
{
    Console.WriteLine("적의 체력이 두 배임");
}

Console.WriteLine($"난이도 {difficulty}");

enum Difficulty
{
    Easy,
    Normal,
    Hard
}

// 값을 직접 지정한 예시
enum Rarity
{
    Common = 10,
    Rare,             // 11 — 바로 위 + 1
    Epic = 50,
    Legendary         // 51
}

// 정수 외의 다른 타입 사용 예시
enum Direction : byte
{
    Up,
    Down,
    Left,
    Right
}

enum BigCode : long
{
    Something
}

// switch + enum 사용 예시
void Describe(Suit suit)
{
    switch (suit)
    {
        case Suit.Spade:
            Console.WriteLine("스페이드 — 검정");
            break;
        case Suit.Heart:
            Console.WriteLine("하트 — 빨강");
            break;
        case Suit.Diamond:
            Console.WriteLine("다이아몬드 — 빨강");
            break;
        case Suit.Club:
            Console.WriteLine("클럽 — 검정");
            break;
    }
}

// switch식 + enum 사용 예시
string GetColor(Suit suit) => suit switch
{
    Suit.Spade => "검정",
    Suit.Club => "검정",
    Suit.Heart => "빨강",
    Suit.Diamond => "빨강",
    _ => "알 수 없음"
};

enum Suit
{
    Spade,
    Heart,
    Diamond,
    Club
}

// 범위에 없는 값 출력과 Enum.IsDefinded 사용 예시
Direction dir = (Direction)99;

Console.WriteLine(dir); // 출력결과 99
Console.WriteLine($"목록에 있는 값인가: {Enum.IsDefined(typeof(Direction), dir)}");

enum Direction
{
    Up,
    Down,
    Left,
    Right
}

// 이름과 값 목록 얻는 예시
string[] names = Enum.GetNames(typeof(Rarity)); // 이름 목록만 String배열로 가져와서 출력
foreach (string name in names)
{
    Console.WriteLine($"  {name}");
}

Array values = Enum.GetValues(typeof(Rarity));  // 값을 가져와서 이름=값 형태로 출력
foreach (Rarity rarity in values)
{
    Console.WriteLine
    ($"  {rarity} = {(int)rarity}");
}

enum Rarity
{
    Common = 1,
    Rare = 5,
    Legendary = 10
}

if(Enum.TryParse("rare", out Rarity rarity))
{
    Console.WriteLine($"대소문자 가림: {rarity}");  // false반환으로 출력 안됨
}
if(Enum.TryParse("rare", true, out Rarity rarity))
{
    Console.WriteLine($"대소문자 무시: {rarity}");  // Rare 출력
}

1  0  1  0   (10진법)
│  │  │  └── 0 × 1    = 0
│  │  └───── 1 × 10   = 10
│  └──────── 0 × 100  = 0
└─────────── 1 × 1000 = 1000
                      = 1010

1  0  1  0   (2진법)
│  │  │  └── 0 × 1 = 0
│  │  └───── 1 × 2 = 2
│  └──────── 0 × 4 = 0
└─────────── 1 × 8 = 8
                   = 10

// 2진수 리터럴 사용 예시
int a = 0b1010;
int b = 0b0000_1010;      // 밑줄로 자리를 나눠 읽기 쉽게 함
int c = 0b1111_1111;

Console.WriteLine($"0b1010      = {a}");
Console.WriteLine($"0b0000_1010 = {b}");
Console.WriteLine($"0b1111_1111 = {c}");

// 16진수 리터럴 사용 예시
Console.WriteLine($"0xF    = {0xF}");
Console.WriteLine($"0xFF   = {0xFF}");
Console.WriteLine($"0x10   = {0x10}");
Console.WriteLine($"0xFFFF = {0xFFFF}");

// 같은 값을 세 가지 표기로
Console.WriteLine($"{255} = {0xFF} = {0b1111_1111}");

// 진법간 변환 예시
int number = 42;
Console.WriteLine($"{number} → 2진수 {Convert.ToString(number, 2)}");
Console.WriteLine($"{number} → 8진수 {Convert.ToString(number, 8)}");
Console.WriteLine($"{number} → 16진수 {Convert.ToString(number, 16)}");

// 문자열에서 되돌리기
Console.WriteLine($"2진수 101010 → {Convert.ToInt32("101010", 2)}");
Console.WriteLine($"16진수 2A     → {Convert.ToInt32("2A", 16)}");

// 16진수로 서식을 지정하며 출력하는 예시
int number = 255;
Console.WriteLine($"{number:X}");      // 출력결과 대문자 FF
Console.WriteLine($"{number:x}");      // 출력결과 소문자 ff
Console.WriteLine($"{number:X4}");     // 출력결과 네 자리로 채움 00FF

// AND 연산 예시
int x = 0b1010;      // 10
int y = 0b1100;      // 12
int result = x & y;

Console.WriteLine($"  {Convert.ToString(x, 2).PadLeft(4, '0')}  ({x})");
Console.WriteLine($"& {Convert.ToString(y, 2).PadLeft(4, '0')}  ({y})");
Console.WriteLine("  ----");
Console.WriteLine($"  {Convert.ToString(result, 2).PadLeft(4, '0')}  ({result})");

// OR 연산 예시
int x = 0b1010;      // 10
int y = 0b1100;      // 12
int result = x | y;

Console.WriteLine($"  {Convert.ToString(x, 2).PadLeft(4, '0')}  ({x})");
Console.WriteLine($"| {Convert.ToString(y, 2).PadLeft(4, '0')}  ({y})");
Console.WriteLine("  ----");
Console.WriteLine($"  {Convert.ToString(result, 2).PadLeft(4, '0')}  ({result})");

// XOR 연산 예시
int x = 0b1010;      // 10
int y = 0b1100;      // 12
int result = x ^ y;

Console.WriteLine($"  {Convert.ToString(x, 2).PadLeft(4, '0')}  ({x})");
Console.WriteLine($"^ {Convert.ToString(y, 2).PadLeft(4, '0')}  ({y})");
Console.WriteLine("  ----");
Console.WriteLine($"  {Convert.ToString(result, 2).PadLeft(4, '0')}  ({result})");

// XOR 두번 연산 예시
int original = 0b1010;
int key = 0b0110;

int scrambled = original ^ key;
int restored = scrambled ^ key;

Console.WriteLine($"원래 값  {Convert.ToString(original, 2).PadLeft(4, '0')}");     // 1010
Console.WriteLine($"섞은 값  {Convert.ToString(scrambled, 2).PadLeft(4, '0')}");    // 1100
Console.WriteLine($"되돌림   {Convert.ToString(restored, 2).PadLeft(4, '0')}");     // 1010

// NOT 연산 예시
byte x = 0b0000_1010;                       // 10
Console.WriteLine($"{x}");                  // 10 출력됨

// byte 로 되돌려 8비트만 봄
byte flipped = (byte)~x;                    // byte로 형변환
Console.WriteLine($"{flipped}");            // 245 출력됨

// int 로 계산하면 32비트가 모두 뒤집힘
Console.WriteLine($"int 로 계산하면 {~x}");  // 형변환 없이 int로 계산하면 -11 출력됨

// 왼쪽 시프트 사용 예시
int number = 0b0000_0011;      // 3

for (int shift = 0; shift <= 4; shift++)
{
    int shifted = number << shift;
    Console.WriteLine($"3 << {shift} = {shifted,3}  {Convert.ToString(shifted, 2).PadLeft(8, '0')}");
}

실행결과
3 << 0 =   3  00000011
3 << 1 =   6  00000110
3 << 2 =  12  00001100
3 << 3 =  24  00011000
3 << 4 =  48  00110000

using System;

int number = 48;

for (int shift = 0; shift <= 4; shift++)
{
    int shifted = number >> shift;
    Console.WriteLine($"48 >> {shift} = {shifted,3}  {Convert.ToString(shifted, 2).PadLeft(8, '0')}");
}

실행결과
48 >> 0 =  48  00110000
48 >> 1 =  24  00011000
48 >> 2 =  12  00001100
48 >> 3 =   6  00000110
48 >> 4 =   3  00000011

// 음수에 대한 오른쪽 시프트 일때의 예시
Console.WriteLine($" 24 >> 2 = {24 >> 2}");     // 출력결과 6
Console.WriteLine($"-24 >> 2 = {-24 >> 2}");    // 출력결과 -6
Console.WriteLine($" -1 >> 5 = {-1 >> 5}");     // 출력결과 -1

// 시프트로 거듭제곱 만드는 예시
for (int n = 0; n < 6; n++)
{
    int value = 1 << n;
    Console.WriteLine($"1 << {n} = {value,2}  {Convert.ToString(value, 2).PadLeft(6, '0')}");
}

실행결과
1 << 0 =  1  000001
1 << 1 =  2  000010
1 << 2 =  4  000100
1 << 3 =  8  001000
1 << 4 = 16  010000
1 << 5 = 32  100000

상태저장 예시
0  0  1  0  1
│  │  │  │  └── 공격력 증가  켜짐
│  │  │  └───── 방어력 증가  꺼짐
│  │  └──────── 이동 속도    켜짐
│  └─────────── 체력 회복    꺼짐
└────────────── 마나 회복    꺼짐

// [Flags] 사용한 열거형 예시
Buff buff = Buff.AttackUp | Buff.SpeedUp;
Console.WriteLine(buff);    // 출력 내용 AttackUp, SpeedUp

[Flags]
enum Buff
{
    None = 0,
    AttackUp = 1,          // 0000 0001
    DefenseUp = 1 << 1,    // 0000 0010
    SpeedUp = 1 << 2,      // 0000 0100
    Regen = 1 << 3         // 0000 1000
}

// [Flags] 사용한 상태와 아닌상태 출력 비교 예시
WithFlags a = WithFlags.A | WithFlags.B;
WithoutFlags b = WithoutFlags.A | WithoutFlags.B;

Console.WriteLine($"[Flags] 붙임   : {a}");     //출력 내용 [Flags] 붙임   : A, B
Console.WriteLine($"[Flags] 안 붙임 : {b}");    //출력 내용 [Flags] 안 붙임 : 3

[Flags]
enum WithFlags
{
    A = 1,
    B = 2
}

enum WithoutFlags
{
    A = 1,
    B = 2
}

// 값이 겹치게 선언한 예시
Wrong w = Wrong.A | Wrong.B;
Console.WriteLine($"A({(int)Wrong.A}) | B({(int)Wrong.B}) = {(int)w} → {w}");
Console.WriteLine($"C 가 켜져 있는가: {(w & Wrong.C) != 0}");

[Flags]
enum Wrong
{
    None = 0,
    A = 1,
    B = 2,
    C = 3        // 잘못됨 — 0011 은 A 와 B 를 합친 것과 같음
}

// 켜기, 확인, 끄기, 뒤집기 사용 예시
Buff buff = Buff.None;
Show("초기", buff);

// 켜기
buff |= Buff.AttackUp;
Show("공격력 증가 켬", buff);

buff |= Buff.SpeedUp;
Show("이동 속도 켬", buff);

// 확인
Console.WriteLine($"공격력 증가? {(buff & Buff.AttackUp) != 0}");
Console.WriteLine($"방어력 증가? {(buff & Buff.DefenseUp) != 0}");

// 끄기
buff &= ~Buff.AttackUp;
Show("공격력 증가 끔", buff);

// 뒤집기
buff ^= Buff.Regen;
Show("체력 회복 뒤집음", buff);

buff ^= Buff.Regen;
Show("체력 회복 다시 뒤집음", buff);

void Show(string label, Buff value)
{
    string bits = Convert.ToString((int)value, 2).PadLeft(4, '0');
    Console.WriteLine($"{bits}  {value,-20}  {label}");
}

[Flags]
enum Buff
{
    None = 0,
    AttackUp = 1,
    DefenseUp = 1 << 1,
    SpeedUp = 1 << 2,
    Regen = 1 << 3
}

실행결과
0000  None                  초기
0001  AttackUp              공격력 증가 켬
0101  AttackUp, SpeedUp     이동 속도 켬
공격력 증가? True
방어력 증가? False
0100  SpeedUp               공격력 증가 끔
1100  SpeedUp, Regen        체력 회복 뒤집음
0100  SpeedUp               체력 회복 다시 뒤집음

        0101   현재 (AttackUp | SpeedUp)
~0001 = 1110   끄려는 자리만 0, 나머지는 1
------------   AND
        0100   그 자리만 꺼지고 나머지는 그대로

// Flags에서 항목 조합하는 예시
[Flags]
enum Buff
{
    None = 0,
    AttackUp = 1,
    DefenseUp = 1 << 1,
    SpeedUp = 1 << 2,
    Regen = 1 << 3,

    // 조합에 이름 붙이기
    Offensive = AttackUp | SpeedUp,
    Defensive = DefenseUp | Regen,
    All = Offensive | Defensive
}

// 켜진 것만 찾는 예시
Buff buff = Buff.AttackUp | Buff.Regen;

Console.WriteLine($"현재 버프: {buff}");
Console.WriteLine("켜진 항목");

foreach (Buff flag in Enum.GetValues(typeof(Buff)))
{
    // None 과 조합 항목은 건너뜀 — 비트가 하나뿐인 것만 봄
    if (flag == Buff.None || ((int)flag & ((int)flag - 1)) != 0)
    {
        continue;
    }

    if ((buff & flag) != 0)
    {
        Console.WriteLine($"  {flag}");
    }
}

[Flags]
enum Buff
{
    None = 0,
    AttackUp = 1,
    DefenseUp = 1 << 1,
    SpeedUp = 1 << 2,
    Regen = 1 << 3,
    Offensive = AttackUp | SpeedUp
}

실행결과
현재 버프: AttackUp, Regen
켜진 항목
  AttackUp
  Regen

// (x & (x - 1)) == 0 예시
int[] values = { 1, 2, 3, 4, 5, 8, 12 };

foreach (int value in values)
{
    bool single = (value & (value - 1)) == 0;
    Console.WriteLine($"{value,2} = {Convert.ToString(value, 2).PadLeft(4, '0')}  비트 하나뿐? {single}");
}

실행결과
 1 = 0001  비트 하나뿐? True
 2 = 0010  비트 하나뿐? True
 3 = 0011  비트 하나뿐? False
 4 = 0100  비트 하나뿐? True
 5 = 0101  비트 하나뿐? False
 8 = 1000  비트 하나뿐? True
12 = 1100  비트 하나뿐? False