대표 프로젝트

입력 데이터 형식 선택과 계정 및 캐릭터 테이블 추가

public class UserStatSystemBuilder : IBuilder<UserStatSystem>
{
    private readonly Queue<BaseClientDataTable> _dataQueue
        = new Queue<BaseClientDataTable>();
    private BaseCharacterData _serverData1;
    private UserProfileData _serverData2;
    private MatchUserProfile _serverData3;
    private BasePlayerData _serverData4;
    private string _name;

    public UserStatSystemBuilder(BaseCharacterData data)
    {
        _serverData1 = data;
    }

    public UserStatSystemBuilder(UserProfileData data)
    {
        _serverData2 = data;
    }

    public UserStatSystemBuilder(MatchUserProfile data)
    {
        _serverData3 = data;
    }

    public UserStatSystemBuilder(BasePlayerData data)
    {
        _serverData4 = data;
    }

    public UserStatSystemBuilder AddData(AccountStatTable statData)
    {
        _dataQueue.Enqueue(statData);
        return this;
    }

    public UserStatSystemBuilder AddData(CharacterStatTable statData)
    {
        _dataQueue.Enqueue(statData);
        return this;
    }

    public UserStatSystem Build()
    {
        var system = new UserStatSystem(_name);

        if (_serverData1 != null)
            system.InitSystem(_serverData1);
        else if (_serverData2 != null)
            system.InitSystem(_serverData2);
        else if (_serverData3 != null)
            system.InitSystem(_serverData3);
        else if (_serverData4 != null)
            system.InitSystem(_serverData4);

        while (_dataQueue.Count > 0)
            system.SetTable(_dataQueue.Dequeue());

        return system;
    }
}

단일 캐릭터와 계정 전체 데이터를 같은 테이블 조합으로 변환

public void InitSystem(BaseCharacterData data)
{
    if (data == null || data.Owner == null)
        return;

    SetTable(new LevelStatTable(data.Owner.LevelStat));
    SetTable(new GymStatTable(data.ID, data.GymStatData));
    SetTable(new CostumeCollectionStatTable(data.Owner.CostumeCollectionList));
    SetTable(new GearStatTable(data.ID, data.GetEquippedAllGearItemList(), data.EquippedOmegaSet, data.Owner.GearPotentialList));
    SetTable(new BioGearStatTable(data.ID, data.EquippedBioInfoList));

    _isNPC = data is AICharacterData;
    CalcMaxHP(data.ID);
    DownReducePercent = data.GetDownReduceHp();
}

public void InitSystem(BasePlayerData data)
{
    if (data?.CharacterDataDict == null)
        return;

    var gymTable = new GymStatTable();
    var gearTable = new GearStatTable();
    var bioGearTable = new BioGearStatTable();

    foreach (BaseCharacterData character in data.CharacterDataDict.Values)
    {
        gymTable.SetLevel(character.ID, character.GymStatData);
        gearTable.SetGearData(character.ID, character.GetEquippedAllGearItemList(), character.EquippedOmegaSet, data.GearPotentialList);
        bioGearTable.SetBioGearInfo(character.ID, character.EquippedBioInfoList);
    }

    SetTable(new LevelStatTable(data.LevelStat));
    SetTable(new CostumeCollectionStatTable(data.CostumeCollectionList));
    SetTable(gymTable);
    SetTable(gearTable);
    SetTable(bioGearTable);

    _isNPC = data.IsBot;
    foreach (BaseCharacterData character in data.CharacterDataDict.Values)
    {
        CalcMaxHP(character.ID);
    }
}

서버와 Unity가 상속하는 공용 계산 기반

public class UserStatSystemServer : UserStatSystemBase
{
}

public class UserStatSystem : UserStatSystemBase
{
    public UserStatSystem() : base()
    {
    }

    public UserStatSystem(string name) : base(name)
    {
    }
}

public void SetTable(BaseClientDataTable table)
{
    if (table == null)
        return;

    table.OwnerSystem = this;

    if (_DynamicStatDataTypes.Contains(table.StatDataType))
    {
        _dynamicStatDataDic[table.StatDataType] = table;
    }
    else
    {
        _staticStatDataDic[table.StatDataType] = table;
    }

    RefreshMaxHP();
}

public int GetLevel(int charId, StatType type)
{
    int level = 0;

    foreach (var item in _staticStatDataDic)
    {
        if (item.Value is AccountStatTable)
        {
            level += (item.Value as AccountStatTable).GetLevel(type);
        }
        else if (item.Value is CharacterStatTable)
        {
            level += (item.Value as CharacterStatTable).GetLevel(charId, type);
        }
    }

    foreach (var item in _dynamicStatDataDic)
    {
        if (item.Value is AccountStatTable)
        {
            level += (item.Value as AccountStatTable).GetLevel(type);
        }
        else if (item.Value is CharacterStatTable)
        {
            level += (item.Value as CharacterStatTable).GetLevel(charId, type);
        }
    }

    return level;
}

public void ApplySystem(UserStatSystemBase targetSystem)
{
    foreach (var table in targetSystem.GetTables())
        SetTable(table.Value);

    DownReducePercent = targetSystem.DownReducePercent;
    _isNPC = targetSystem._isNPC;

    _maxHpDic.Clear();
    _reciprocalMaxHpDic.Clear();

    foreach (var item in targetSystem._maxHpDic)
        _maxHpDic[item.Key] = item.Value;

    foreach (var item in targetSystem._reciprocalMaxHpDic)
        _reciprocalMaxHpDic[item.Key] = item.Value;
}

public Character BuildCharacter()
{
    Character character = CreateCharacter();
    character.statSystem.ApplySystem(_playerData.StatSystem);
    return character;
}

UILabel의 처리 텍스트 생성과 실제 렌더링 연결

public string processedText
{
    get
    {
        if (mLastWidth != mWidth || mLastHeight != mHeight)
        {
            mLastWidth = mWidth;
            mLastHeight = mHeight;
            mShouldBeProcessed = true;
        }

        if (shouldBeProcessed)
            ProcessText();

        return mProcessedText;
    }
}

public void ProcessText(bool legacyMode = false, bool full = true)
{
    if (!isValid)
        return;

    mChanged = true;
    shouldBeProcessed = false;

    if (full)
        UpdateNGUIText();

    // rect, region, font size와 Overflow 계산은 기존 NGUI 로직을 사용합니다.
    NGUIText.Update(false);
    bool fits = NGUIText.WrapText(printedText, out mProcessedText, false, false, mOverflow == Overflow.ClampContent && mOverflowEllipsis);

    ArabicSupport.ArabicConverter.FixNGUI(ref mProcessedText, this);
    mCalculatedSize = NGUIText.CalculatePrintedSize(mProcessedText);
}

public override void OnFill(List<Vector3> verts, List<Vector2> uvs, List<Color> cols)
{
    if (!isValid)
        return;

    string text = processedText;
    UpdateNGUIText();
    NGUIText.Print(text, verts, uvs, cols);
}

Arabic 구간과 혼합 문자열 분리 및 복원

public static void FixNGUI(ref string text, UILabel label = null)
{
    if (IsRtl(text) == false)
        return;

    bbcodeDatas.Clear();
    braketDatas.Clear();
    nonArabicDatas.Clear();

    ConvertString(ref text, label);
    DeconvertString(ref text);
}

private static void ConvertString(ref string input, UILabel label)
{
    string result = Regex.Replace(
        input.TrimStart(),
        BBCodePattern,
        match =>
        {
            bbcodeDatas.Add(match.Value);
            return BBCodeConvertKeyWord;
        });

    result = Regex.Replace(
        result,
        BracketPattern,
        match =>
        {
            braketDatas.Add(match.Value);
            return BracketPatternKey;
        });

    result = Regex.Replace(
        result,
        NonArabicPattern,
        match =>
        {
            if (match.Value.Contains(BracketPatternKey.Trim()) || match.Value.Contains(BBCodeConvertKeyWord.Trim()))
            {
                return match.Value;
            }

            nonArabicDatas.Add(match.Value);
            return NonArabicPatternKey;
        });

    input = Fix(result, false, false);
}

private static void DeconvertString(ref string input)
{
    int index = 0;
    input = Regex.Replace(input, NonArabicDePattern, _ => nonArabicDatas[index++]);

    index = 0;
    input = Regex.Replace(
        input,
        BracketDePattern,
        _ =>
        {
            string value = braketDatas[index++];
            char first = value[0];
            char last = value[value.Length - 1];
            string body = ArabicTool.FixLine(value.Substring(1, value.Length - 2));
            return $"{first}{body}{last}";
        });
}

특수 규칙이 있는 Arabic 문자 조합, 글자 위치별 형태와 문장 부호 처리

internal static string FixLine(string text)
{
    List<TashkeelLocation> tashkeelLocations;
    string origin = RemoveTashkeel(text, out tashkeelLocations);

    char[] source = origin.ToCharArray();
    char[] result = origin.ToCharArray();

    for (int index = 0; index < source.Length; index++)
        source[index] = (char)ArabicTable.ArabicMapper.Convert(source[index]);

    for (int index = 0; index < source.Length; index++)
    {
        bool combined = false;
        if (source[index] == (char)IsolatedArabicLetters.Lam && index < source.Length - 1)
        {
            if (source[index + 1] == (char)IsolatedArabicLetters.Alef)
            {
                source[index] = (char)0xFEF9;
                result[index + 1] = (char)0xFFFF;
                combined = true;
            }
            else if (source[index + 1] == (char)IsolatedArabicLetters.AlefHamza)
            {
                source[index] = (char)0xFEF5;
                result[index + 1] = (char)0xFFFF;
                combined = true;
            }
        }

        if (IsIgnoredCharacter(source[index]) == false)
        {
            if (IsMiddleLetter(source, index))
                result[index] = (char)(source[index] + 3);
            else if (IsFinishingLetter(source, index))
                result[index] = (char)(source[index] + 1);
            else if (IsLeadingLetter(source, index))
                result[index] = (char)(source[index] + 2);
        }

        if (PunctuationMapper.TryGetValue(source[index], out char punctuation))
        {
            result[index] = punctuation;
        }

        if (combined)
            index++;
    }

    if (showTashkeel)
        result = ReturnTashkeel(result, tashkeelLocations);

    Array.Reverse(result);
    return new string(result.Where(value => value != (char)0xFFFF).ToArray());
}

캐릭터와 장비 세트 조건에 따른 적용과 해제

if (_bossPasiveSkillDataDict.TryGetValue(eBotSkillTriggerType.APPLY_BUFF_TARGET_CHARACTER, out var characterBuffs))
{
    foreach (BotSkillData data in characterBuffs)
    {
        if (data.TriggerData.Target.HasFlag(eBotSkillTriggerTarget.Target) && target.CharId == data.TriggerData.Value)
            ApplyBuff(data);
        else
            RemoveBuff(data);
    }
}

if (_bossPasiveSkillDataDict.TryGetValue(eBotSkillTriggerType.APPLY_BUFF_EQUIP_TARGET_GEARSET, out var gearSetBuffs))
{
    foreach (BotSkillData data in gearSetBuffs)
    {
        if (data.TriggerData.Target.HasFlag(eBotSkillTriggerTarget.Target) && CheckGearPotential(target, data.TriggerData.Value))
            ApplyBuff(data);
        else
            RemoveBuff(data);
    }
}

실제 피해가 발생한 공격 타입과 대상 확인

if (result.isAnyHitWithDamage &&
    _bossPasiveSkillDataDict.TryGetValue(eBotSkillTriggerType.APPLY_BUFF_ON_HIT, out var hitBuffs))
{
    foreach (BotSkillData data in hitBuffs)
    {
        bool attackTypeMatched = result.hitter.curAttack.type == (AttackType)data.TriggerData.Param ||
                                 data.TriggerData.Param == 4;

        if (attackTypeMatched &&
            result.hitter == target &&
            data.TriggerData.Target.HasFlag(eBotSkillTriggerTarget.Target))
        {
            ApplyBuff(data);
        }
    }
}

Presenter, View, Model 연결과 초기화 순서

public abstract class BasePresenterN<ViewType, ModelType> : BasePresenterN where ViewType : class, new() where ModelType : class, new()
{
    public ViewType View => _baseView as ViewType;
    public ModelType Model => _baseModel as ModelType;

    public override async UniTask Init(params object[] data)
    {
        if (_baseModel == null)
        {
            _baseModel = (new ModelType() as BaseModel).SetModel(this);
        }

        await base.Init(data);
    }
}

public abstract class BasePresenterN : MonoBehaviour
{
    [SerializeField] protected BaseView _baseView;
    protected BaseModel _baseModel;

    public virtual async UniTask Init(params object[] data)
    {
        FacadeManager.Server.ReceivePacketObservable.Where(packet => packet != null).Subscribe(OnPacket).AddTo(gameObject);

        if (_baseView != null)
            await _baseView.Init(data);
    }

    public virtual async UniTask Show(params object[] data)
    {
        if (_baseView != null)
            await _baseView.Show(data);
    }
}

public abstract class BaseView<T> : BaseView where T : BasePresenterN
{
    public T Presenter => _basePresenter as T;
}

Popup 최초 생성과 이후 인스턴스 재사용

public PopupBase Get(PopupStyle style, params object[] data)
{
    var popup = _listPopup.Find(item => item.name.Equals(GetPopupName(style)));

    if (popup != null)
        return popup;

    GameObject prefab = Resources.Load<GameObject>($"{PopupPath}{GetPopupName(style)}");
    if (prefab == null)
        return null;

    PopupBase instance = Instantiate(prefab.GetComponent<PopupBase>());
    instance.name = prefab.name;
    _listPopup.Add(instance);
    return instance;
}

public async UniTask<PopupBase> Show(PopupStyle style, bool showLoading, params object[] data)
{
    var popup = Get(style, data);
    popup.gameObject.SetActive(true);

    if (popup.isLoad == false)
        await popup.Load();

    await popup.Show(data);
    return popup;
}

스크롤 방향별 시스템 생성과 셀 재배치

private void Init()
{
    if (_direction == EDirectionType.Vertical)
    {
        _recyclingSystem = new VerticalRecyclingSystem(_baseCell, this, _handler, _isGrid, LineCount, _initCount, _isControlChildsSize);
    }
    else
    {
        _recyclingSystem = new HorizontalRecyclingSystem(_baseCell, this, _handler, _isGrid, LineCount, _initCount, _isControlChildsSize);
    }

    _recyclingSystem.Init(() => onValueChanged.AddListener(OnScrollValueChanged));
}

public override Vector2 OnValueChangedListener(Vector2 direction)
{
    RefreshBounds();

    if (direction.y > 0 && _cellPool[_lastIndex].MaxY() > _recyclableViewBounds.min.y)
    {
        return RecycleTopToBottom();
    }

    if (direction.y < 0 && _cellPool[_firstIndex].MinY() < _recyclableViewBounds.max.y)
    {
        return RecycleBottomToTop();
    }

    return Vector2.zero;
}

private Vector2 RecycleTopToBottom()
{
    float nextY = _cellPool[_lastIndex].anchoredPosition.y
        - _cellPool[_lastIndex].sizeDelta.y;

    _cellPool[_firstIndex].anchoredPosition = new Vector2(_cellPool[_firstIndex].anchoredPosition.x, nextY);

    Handler?.OnRecycling(_cellList[_firstIndex], _currentItemCount);
    indexInfoDict[_cellList[_firstIndex]] = _currentItemCount;

    _lastIndex = _firstIndex;
    _firstIndex = (_firstIndex + 1) % _cellPool.Count;
    _currentItemCount++;

    return Vector2.zero;
}

기존 상태 종료 후 다음 상태를 시작하는 전환 순서

public void ChangeState(Enum nextState, params object[] args)
{
    if (states.ContainsKey(nextState) == false)
        throw new Exception("Invalid State " + nextState);

    if (currentState != null && states.ContainsKey(currentState))
    {
        states[currentState].Leave(args);
    }

    currentState = nextState;
    states[currentState].Enter(args);
}

키 입력 감지와 진행 중인 Command 실행을 분리한 갱신 흐름

public void SetKeyCmd(ICommand<Player, Model> command, KeyCode keyCode, Func<KeyCode, bool> inputCondition)
{
    keyMatchingDict.TryAdd(keyCode, command);
    updateKeyCodeList.Add(new KeyMatchData<Player, Model>
    {
        keyAction = inputCondition,
        key = keyCode,
        command = command
    });
}

public void CommandUpdate(float deltaTime)
{
    foreach (var command in commandDict.Values)
        command.ReSet();

    for (int i = 0; i < updateKeyCodeList.Count; i++)
    {
        var keyMatch = updateKeyCodeList[i];
        if (keyMatch.keyAction.Invoke(keyMatch.key))
            keyMatch.command.Catch(keyMatch.key);
    }

    foreach (var command in commandDict.Values)
    {
        if (command.IsProgress() || command.IsCatch())
            command.Execute(deltaTime);
        else
            command.Idle(deltaTime);
    }
}

행동이 진행 중이면 계속 실행하고 종료 후 새 패턴을 선택하는 Command

public override void Execute(float deltaTime)
{
    if (isProgress)
    {
        actionPattern.Execute(deltaTime);
        if (actionPattern.IsEnd())
        {
            isProgress = false;
            ReSet();
        }
        return;
    }

    var enemies = mainModel.unitModel.GetRoundEnemies(player);
    var target = Const.FindShortestTarget(player, enemies, 10000f);

    player.GetBoard().TargetManager.SetMainTarget(target, true);
    isProgress = actionPattern.TryPickAnyPattern();
}

인터페이스 구현 형식을 검색해 통합 도구 창에 실행 버튼 등록

foreach (Type type in Assembly.GetAssembly(typeof(ISuperKolaTool)).GetTypes())
{
    if (type.GetInterface(nameof(ISuperKolaTool)) == null)
        continue;

    MethodInfo openWindow = type.GetMethod("OpenWindow", BindingFlags.Static | BindingFlags.Public);

    Button button = new Button(() => openWindow.Invoke(null, null));
    button.text = type.Name;
    root.Add(button);
}

공격자와 피격자 조건을 순서대로 적용하는 기록 조회

private IEnumerable<KeyValuePair<DateTime, AttackDebugInfo>> GetDatas()
{
    IEnumerable<KeyValuePair<DateTime, AttackDebugInfo>> filtered;

    if (string.IsNullOrEmpty(_dropdownHitter.value) || _dropdownHitter.value == "ALL")
    {
        filtered = _debugInfos;
    }
    else
    {
        filtered = _debugInfos.Where(item => item.Value.hitter == _dropdownHitter.value);
    }

    if (string.IsNullOrEmpty(_dropdownVictim.value) == false && _dropdownVictim.value != "ALL")
    {
        filtered = filtered.Where(item => item.Value.victim == _dropdownVictim.value);
    }

    return filtered;
}

private void SelectRecord(int index)
{
    if (index < 0 || index >= _infoList.Count)
        return;

    _currentInfo = _infoList[index];
    _textBoxBody.value = _currentInfo.body;
}

전투 이벤트 구독, 기록 추가와 JSON 저장

private void OnClickRecord()
{
    _isRecord = !_isRecord;
    _stream?.Dispose();

    if (_isRecord)
    {
        _stream = RTPawnData._EDITOR_RTPAWN_ONATTACK.Subscribe(OnAttack);
    }
}

public void OnAttack((RTPawnData hitter, RTPawnData victim, string body) data)
{
    if (_isRecord == false)
        return;

    var record = new AttackDebugInfo
    {
        hitter = data.hitter.GetName().ToTableText(),
        victim = data.victim.GetName().ToTableText(),
        body = data.body
    };

    _debugInfos.Add(DateTime.Now, record);
    File.WriteAllText(_DATA_PATH, JsonConvert.SerializeObject(_debugInfos));
}

요청 작업과 응답 대기 객체 등록

public async UniTask<T> SendConcurrencyPacket<T>(RestProtocolType protocol, object request = null, int reSendCount = 5)
{
    var tcs = new UniTaskCompletionSource<T>();
    var queue = _protocolQueues.GetOrAdd(protocol, _ => new ConcurrentQueue<Func<UniTask>>());

    queue.Enqueue(async () =>
    {
        _responseTasks.GetOrAdd(protocol, _ => new ConcurrentQueue<object>()).Enqueue(tcs);

        SendRest(new RestMessageData
        {
            protocol = (int)protocol,
            requestPacket = request,
            reSendCount = reSendCount
        });

        await tcs.Task;
    });

    TriggerProtocolProcessing(protocol);
    return await tcs.Task;
}

private void SendRest(RestMessageData restPacket)
{
    JObject jsonObject;

    if (restPacket.requestPacket != null)
    {
        jsonObject = JObject.FromObject(restPacket.requestPacket);
    }
    else
    {
        jsonObject = JObject.FromObject(new RESTRequestBase());
    }

    RestController.Instance.SendObject((RestProtocolType)restPacket.protocol, jsonObject, restPacket.reSendCount);
}

프로토콜별 단일 소비자와 FIFO 실행

private async void TriggerProtocolProcessing(RestProtocolType protocol)
{
    if (_isProcessingProtocol.TryAdd(protocol, true) == false)
        return;

    try
    {
        var queue = _protocolQueues[protocol];
        while (queue.TryDequeue(out var workItem))
        {
            try
            {
                await workItem();
            }
            catch (Exception exception)
            {
                Debug.LogError($"Processing exception for {protocol}: " + exception);
            }
        }
    }
    finally
    {
        _isProcessingProtocol.TryRemove(protocol, out _);
    }
}

public void SubscribeResponse<T>(RestProtocolType protocol) where T : RESTResponseBase
{
    MessageBroker.Default.Receive<T>().Subscribe(response =>
        {
            if (_responseTasks.TryGetValue(protocol, out var queue) && queue.TryDequeue(out object source) && source is UniTaskCompletionSource<T> tcs)
            {
                tcs.TrySetResult(response);
            }
        }).AddTo(this);
}

길드명과 재화 검증 후 서버 성공 응답에서 UI 갱신

private async void OnClickCreate()
{
    if (string.IsNullOrWhiteSpace(_guildNameInput.text))
        return;

    if (UserInventoryDataController.Instance.GetItemCount(COST_ITEM_ID) < _cost)
    {
        OnPurchaseFailure();
        return;
    }

    RES_CreateGuild response = await REST_CreateGuild.SendPacket(
        new REQ_CreateGuild { guildName = _guildNameInput.text });

    if (response.result == ResponseCode.SUCCESS)
    {
        onCreateGuild?.Invoke();
        Close();
    }
}

표시 상태와 절전 모드에 따른 채팅 조회 간격

private readonly Dictionary<eChatState, ChatStateSetting> _chatStateSettings = new()
{
    { eChatState.SHOWING, new ChatStateSetting { refreshTime = 2f } },
    { eChatState.HIDING, new ChatStateSetting { refreshTime = 7f } },
    { eChatState.SLEEP, new ChatStateSetting { refreshTime = 0f } }
};

private void Update()
{
    if (_chatState == eChatState.SLEEP)
        return;

    if (_isLock == false &&
        (DateTime.UtcNow - _lastCheckTime).TotalSeconds > _chatStateSettings[_chatState].refreshTime)
    {
        ChatCheck();
    }
}

광고 또는 티켓 사용 조건 확인

private static async UniTask<bool> ProcessPayment(GachaType gachaType, SummonConfig config)
{
    if (config.summonCost <= 0)
    {
        eAdsCategory category = gachaType == GachaType.Skill ? eAdsCategory.Ads_Skill : eAdsCategory.Ads_Equip;

        var adResult = await AdvertisementManager.Instance.ShowRewardedAd(category);
        return adResult != null;
    }

    ItemEffect expectedEffect = gachaType == GachaType.Skill ? ItemEffect.Consume_SkillTicket : ItemEffect.Consume_EquipTicket;
    var consumeItem = ItemDataCollection.FindById(config.consumeItemIdx);

    if (consumeItem.itemEffect != expectedEffect)
        return false;

    int itemCount = UserInventoryDataController.Instance.GetItemCount(consumeItem.index);
    return itemCount >= config.summonCost;
}

입력 잠금, 서버 요청과 성공 후 상태 갱신

public static async UniTask<bool> Gacha(GachaType gachaType, SummonConfig config, Action<GachaResult> onComplete)
{
    if (flag)
        return false;

    if (IsUnlock(gachaType) == false)
    {
        onComplete?.Invoke(new GachaResult(false, 0, null, gachaType, eGachaResult.Fail));
        return false;
    }

    GachaResult resultData = null;
    bool success = false;
    var progress = PopupUIManager.Instance.ShowGachaProgressPopupUI();

    try
    {
        flag = true;
        bool paid = await ProcessPayment(gachaType, config);
        if (paid)
        {
            var response = await REST_GachaItem.SendPacket(
                new REQ_GachaItem
                {
                    summonConfigIndex = config.index
                });

            success = response.result == ResponseCode.SUCCESS;
            if (success)
            {
                횟수증가(gachaType, config.rewardCount);
                resultData = new GachaResult(true, config.rewardCount, response.ResultItem, gachaType);

                GameEventManager.Publish(new GachaEventParam
                {
                    count = config.rewardCount,
                    gachaType = gachaType
                });

                if (config.index == 1 || config.index == 6)
                {
                    eAdsCategory category = gachaType == GachaType.Skill ? eAdsCategory.Ads_Skill : eAdsCategory.Ads_Equip;
                    await AdvertisementManager.Instance.SaveAdTime(category);
                }

                UserDataManager.UpdateTotalStat(true).Forget();
            }
        }
    }
    catch (Exception exception)
    {
        Debug.LogError(exception);
    }
    finally
    {
        flag = false;
        resultData ??= new GachaResult(false, config.rewardCount, null, gachaType, eGachaResult.ServerError);
        await progress.Complete();
    }

    onComplete?.Invoke(resultData);
    return success;
}

워크북 시트를 일반 테이블과 enum으로 분류

for (int index = 1; index <= worksheets.Count; index++)
{
    Worksheet sheet = (Worksheet)worksheets[index];
    try
    {
        if (sheet.Name.StartsWith("_"))
            continue;

        string csvPath = $"{outputPath}/{sheet.Name}.csv";
        sheet.SaveAs(csvPath, XlFileFormat.xlCSVUTF8, Local: true);

        if (sheet.Name.StartsWith("enum_", StringComparison.OrdinalIgnoreCase))
        {
            enumList.Add(csvPath);
        }
        else
        {
            tableList.Add(csvPath);
        }
    }
    finally
    {
        ReleaseComObject(sheet);
    }
}

같은 시트에서 Client와 Server 결과를 각각 생성

foreach (string csvPath in tableList)
{
    var client = new CSVReader(csvPath, CSVWriteType.Client);
    var server = new CSVReader(csvPath, CSVWriteType.Server);

    string tableName = Path.GetFileName(csvPath);
    if (tableName.EndsWith("Table.csv", StringComparison.OrdinalIgnoreCase) == false)
    {
        tableName = tableName.Replace(".csv", "Table.csv");
    }

    FileExtension.ProcessCreateFile(PATH_OUTPUT_CLIENT_CSV, tableName, client.GetCSV());
    FileExtension.ProcessCreateFile(PATH_OUTPUT_SERVER_CSV, tableName, server.GetCSV());

    string scriptName = tableName.Replace(".csv", ".cs");

    string clientCode = client.GetClassCode();
    if (clientCode != null)
    {
        FileExtension.ProcessCreateFile(PATH_OUTPUT_CLIENT_SCRIPT, scriptName, clientCode);
    }

    string serverCode = server.GetClassCode();
    if (serverCode != null)
    {
        FileExtension.ProcessCreateFile(PATH_OUTPUT_SERVER_SCRIPT, scriptName, serverCode);
    }
}

CSVReader의 출력 대상, 캐시와 입력 파일 구성

public enum CSVWriteType
{
    None = 0,
    Server = 1 << 0,
    Client = 1 << 1
}

private static readonly HashSet<string> s_numericTypes = new(StringComparer.OrdinalIgnoreCase)
    {
        "int", "long", "short", "float", "double",
        "uint", "ulong", "ushort"
    };

private readonly Dictionary<int, string> columns = new();
private readonly Dictionary<int, string> dataTypes = new();
private readonly Dictionary<int, Dictionary<int, string>>
    resultDataLines = new();
private readonly string _csvPath;
private readonly CSVWriteType _buildType;

public CSVReader(string csvPath, params CSVWriteType[] targets)
{
    _csvPath = csvPath;
    _buildType = CSVWriteType.None;

    foreach (CSVWriteType target in targets)
        _buildType |= target;
}

CSV 파싱과 빌드 대상별 컬럼 및 데이터 선택

private void LoadData()
{
    if (columns.Count != 0)
        return;

    string sheetName = Path.GetFileName(_csvPath);
    string text = File.ReadAllText(_csvPath, Encoding.UTF8);
    List<string[]> records = ParseCsv(text);

    string[] columnNames = GetRecord(records, Config.Default.ColumnNameRow, sheetName);
    string[] buildTargets = GetRecord(records, Config.Default.BuildTargetRow, sheetName);
    string[] sourceTypes = GetRecord(records, Config.Default.DataTypeRow, sheetName);

    int metadataColumnCount = Math.Max(columnNames.Length, Math.Max(buildTargets.Length, sourceTypes.Length));
    int startColumn = Math.Max(0, Config.Default.StartColumn);

    for (int column = startColumn; column < metadataColumnCount; column++)
    {
        string name = GetCell(columnNames, column);
        string target = GetCell(buildTargets, column);
        string type = GetCell(sourceTypes, column);

        if (string.IsNullOrWhiteSpace(name) || name.StartsWith('#') || string.IsNullOrWhiteSpace(target) || string.IsNullOrWhiteSpace(type))
        {
            continue;
        }

        bool included = target.Equals("both", StringComparison.OrdinalIgnoreCase) || target.Equals(_buildType.ToString(), StringComparison.OrdinalIgnoreCase);
        if (included == false)
            continue;

        columns.Add(column, name);
        dataTypes.Add(column, type.Replace("\"", ""));
    }

    for (int row = Config.Default.DataRow; row < records.Count; row++)
    {
        if (records[row].All(string.IsNullOrWhiteSpace))
            continue;

        foreach (int column in columns.Keys)
        {
            string cell = GetCell(records[row], column);
            if (s_numericTypes.Contains(dataTypes[column]))
                cell = cell.Replace(",", "");

            if (resultDataLines.ContainsKey(row) == false)
            {
                resultDataLines[row] = new Dictionary<int, string>();
            }
            resultDataLines[row][column] = cell;
        }
    }
}

private static string[] GetRecord(List<string[]> records, int index, string sheetName)
{
    if (index < 0 || index >= records.Count)
    {
        throw new InvalidDataException($"{sheetName}: CSV 설정 행 {index}을 찾을 수 없습니다.");
    }

    return records[index];
}

private static string GetCell(string[] cells, int index)
{
    return index >= 0 && index < cells.Length ? cells[index] : string.Empty;
}

따옴표, 쉼표와 줄바꿈을 유지하는 CSV 파싱과 출력

private static List<string[]> ParseCsv(string text)
{
    var records = new List<string[]>();
    var fields = new List<string>();
    var field = new StringBuilder();
    bool isQuoted = false;

    for (int index = 0; index < text.Length; index++)
    {
        char current = text[index];
        if (isQuoted)
        {
            if (current == '\"')
            {
                if (index + 1 < text.Length && text[index + 1] == '\"')
                {
                    field.Append('\"');
                    index++;
                }
                else
                {
                    isQuoted = false;
                }
            }
            else
            {
                field.Append(current);
            }
            continue;
        }

        if (current == '\"' && field.Length == 0)
        {
            isQuoted = true;
        }
        else if (current == ',')
        {
            fields.Add(field.ToString());
            field.Clear();
        }
        else if (current == '\r' || current == '\n')
        {
            if (current == '\r' && index + 1 < text.Length && text[index + 1] == '\n')
            {
                index++;
            }

            fields.Add(field.ToString());
            field.Clear();
            records.Add(fields.ToArray());
            fields.Clear();
        }
        else
        {
            field.Append(current);
        }
    }

    if (isQuoted)
        throw new FormatException("닫히지 않은 CSV 필드입니다.");

    if (field.Length > 0 || fields.Count > 0)
    {
        fields.Add(field.ToString());
        records.Add(fields.ToArray());
    }

    return records;
}

private static string EscapeCsvField(string value)
{
    if (value.IndexOfAny(
        new[] { ',', '\"', '\r', '\n' }) < 0)
    {
        return value;
    }

    return $"\"{value.Replace("\"", "\"\"")}\"";
}

public string GetCSV()
{
    LoadData();
    var builder = new StringBuilder();
    builder.AppendLine(string.Join(',', columns.Values.Select(EscapeCsvField)));

    if (dataTypes.Count > 0)
    {
        builder.AppendLine(string.Join(',', dataTypes.Values.Select(EscapeCsvField)));
    }

    foreach (var row in resultDataLines.Values)
    {
        builder.AppendLine(string.Join(',', row.Values.Select(EscapeCsvField)));
    }

    return builder.ToString();
}

컬럼 타입으로 테이블 데이터 클래스와 조회 키 생성

public string GetClassCode()
{
    LoadData();
    if (resultDataLines.Count == 0)
        return null;

    string className = Path.GetFileName(_csvPath).Replace(".csv", "");
    if (className.EndsWith("Table", StringComparison.OrdinalIgnoreCase) == false)
    {
        className += "Table";
    }

    var indexColumn = columns.FirstOrDefault(column => dataTypes[column.Key].Equals("Index", StringComparison.OrdinalIgnoreCase));
    string indexType = indexColumn.Value == null || int.TryParse(resultDataLines.First().Value[indexColumn.Key], out _) ? "int" : "string";

    var properties = columns.Select(column => SyntaxFactory.PropertyDeclaration(SyntaxFactory.ParseTypeName(column.Key == indexColumn.Key ? indexType : dataTypes[column.Key]), column.Value).AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword)).AddAccessorListAccessors(SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)), SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration).WithModifiers(SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PrivateKeyword))).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)))).ToList();

    MethodDeclarationSyntax getKeyMethod;
    if (indexColumn.Value == null)
    {
        properties.Add(SyntaxFactory.PropertyDeclaration(SyntaxFactory.ParseTypeName("int"), "Index_AutoIncremented").AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword)).AddAccessorListAccessors(SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)), SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration).WithModifiers(SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PrivateKeyword))).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken))));

        getKeyMethod = SyntaxFactory.MethodDeclaration(SyntaxFactory.ParseTypeName(indexType), "GetKey").AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword), SyntaxFactory.Token(SyntaxKind.OverrideKeyword)).WithExpressionBody(SyntaxFactory.ArrowExpressionClause(SyntaxFactory.IdentifierName("Index_AutoIncremented"))).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken));
    }
    else
    {
        getKeyMethod = SyntaxFactory.MethodDeclaration(SyntaxFactory.ParseTypeName(indexType), "GetKey").AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword), SyntaxFactory.Token(SyntaxKind.OverrideKeyword)).WithExpressionBody(SyntaxFactory.ArrowExpressionClause(SyntaxFactory.IdentifierName(indexColumn.Value))).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken));
    }

    var dataClass = SyntaxFactory.ClassDeclaration($"{className}Data").AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword), SyntaxFactory.Token(SyntaxKind.PartialKeyword)).AddBaseListTypes(SyntaxFactory.SimpleBaseType(SyntaxFactory.ParseTypeName($"BaseTableData<{indexType}>"))).AddMembers(properties.ToArray()).AddMembers(getKeyMethod);

    var tableClass = SyntaxFactory.ClassDeclaration(className).AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword), SyntaxFactory.Token(SyntaxKind.PartialKeyword)).AddBaseListTypes(SyntaxFactory.SimpleBaseType(SyntaxFactory.ParseTypeName($"BaseTable<{className}Data, {indexType}>")));

    var compilationUnit = SyntaxFactory.CompilationUnit().AddUsings(SyntaxFactory.UsingDirective(SyntaxFactory.ParseName("System")), SyntaxFactory.UsingDirective(SyntaxFactory.ParseName("System.Collections.Generic")));

    if (string.IsNullOrWhiteSpace(Config.Default.ResultNameSpace) == false)
    {
        compilationUnit = compilationUnit.AddMembers(SyntaxFactory.NamespaceDeclaration(SyntaxFactory.ParseName(Config.Default.ResultNameSpace)).AddMembers(dataClass, tableClass));
    }
    else
    {
        compilationUnit = compilationUnit.AddMembers(dataClass, tableClass);
    }

    return compilationUnit.NormalizeWhitespace().ToFullString();
}

출력 폴더 생성과 파일 저장, Excel COM 객체 정리

public static string ProcessCreateFile(string directory, string fileName, string body)
{
    string path = Path.Combine(directory, fileName);
    string parent = Path.GetDirectoryName(path);

    if (parent != null && Directory.Exists(parent) == false)
    {
        Directory.CreateDirectory(parent);
    }

    File.WriteAllText(path, body, Encoding.UTF8);
    return path;
}

private static void ReleaseComObject(object comObject)
{
    if (comObject != null && Marshal.IsComObject(comObject))
    {
        Marshal.FinalReleaseComObject(comObject);
    }
}

씬과 전투 종료 조건을 연결한 웨이브 대기

try
{
    await UniTask.Delay(TimeSpan.FromSeconds(targetWave.Duration), cancellationToken: _parent.UI.GetCancellationTokenOnDestroy()).AttachExternalCancellation(_spawnCts.Token);
}
catch (OperationCanceledException)
{
    return;
}

public void Dispose()
{
    _spawnCts?.Cancel();
    _spawnCts?.Dispose();
    _spawnCts = null;
}

Destroy 없이 풀로 반환되는 유닛의 수명 종료

private CancellationTokenSource _destroyOrDeadCts;

public new CancellationToken destroyCancellationToken
{
    get
    {
        if (_destroyOrDeadCts == null)
            _destroyOrDeadCts = new CancellationTokenSource();

        return _destroyOrDeadCts.Token;
    }
}

protected async virtual UniTask OnDead(bool canRevive)
{
    _destroyOrDeadCts?.Cancel();
    _destroyOrDeadCts?.Dispose();
    _destroyOrDeadCts = null;

    await SkillHandler.OnDead(Killer);
}

테이블 값으로 웨이브 생성 전략 선택

switch (targetWave.Pattern)
{
    case WavePattern.Progressive:
        targetWavePattern = new ProgressiveWave(targetWave.PatternParameter[0]);
        break;
    case WavePattern.Uniform:
        targetWavePattern = new UniformWave(targetWave.PatternParameter[0]);
        break;
    case WavePattern.FixedLine:
        targetWavePattern = new FixedLineWave(targetWave.PatternParameter);
        break;
    default:
        targetWavePattern = new RandomWave(_parent.BattleField.CreatedRow, targetWave.PatternParameter[0]);
        break;
}

공통 인터페이스 뒤에서 중앙 라인을 기준으로 생성 범위를 넓히는 Progressive 전략

public interface IWavePattern
{
    Vector3Int GetSpawnTileCoordinate();
}

public sealed class ProgressiveWave : IWavePattern
{
    private readonly int _createdRow;
    private readonly int _center;
    private readonly HashSet<int> _lines = new();
    private int _step;

    public ProgressiveWave(int createdRow)
    {
        _createdRow = createdRow;
        _center = createdRow / 2;
        _lines.Add(_center);
    }

    public Vector3Int GetSpawnTileCoordinate()
    {
        if (_step < _createdRow / 2)
        {
            int upper = _center - _step;
            int lower = _center + _step;

            if (upper >= 0)
                _lines.Add(upper);
            if (lower < _createdRow)
                _lines.Add(lower);

            _step++;
        }

        int index = UnityEngine.Random.Range(0, _lines.Count);
        int selectedLine = _lines.ElementAt(index);
        return new Vector3Int(-3, selectedLine);
    }
}

DetectionType에 따른 스킬 대상 탐색

case DetectionType.Circle:
{
    Collider2D[] hits = Physics2D.OverlapCircleAll(Caster.transform.position, TableData.DetectionValue, LayerMask.GetMask("Unit"));

    foreach (var col in hits)
    {
        var enemy = col.GetComponent<Unit>();
        if (enemy == null || CheckCasting(enemy, type) == false)
            continue;

        if (Effects.All(effect => effect.IsValid(enemy)))
            candidates.Add(enemy);
    }
    break;
}

Jenkins 입력값에 따른 환경 심볼 설정

switch (buildType.ToLower())
{
    case "dev":
        defineSymbols = "LOCAL;NET_LOG;DEV;DEBUG";
        break;
    case "qa":
        defineSymbols = "STAGING";
        break;
    case "live":
        defineSymbols = "LIVE";
        break;
}

PlayerSettings.SetScriptingDefineSymbols(namedBuildTarget, defineSymbols);

content state 유무에 따른 Addressables 빌드 분기

string previousStatePath = $"Assets/AddressableAssetsData/{buildTarget}/" + "addressables_content_state.bin";

if (File.Exists(previousStatePath))
{
    ContentUpdateScript.BuildContentUpdate(settings, previousStatePath);
}
else
{
    AddressableAssetSettings.BuildPlayerContent();
}

모드가 공유하는 웨이브와 전투 종료 처리

public async UniTask PrepareForBattleUnload(SceneInstance loadedScene, Battle battle)
{
    if (loadedScene.Scene.IsValid())
    {
        battle?.Dispose();
        await SceneManager.UnloadSceneAsync(loadedScene.Scene);
    }
}

public void SetWaveInfo(int current, int max)
{
    WaveInfoLabel.text = $"WAVE {current}/{max}";
    WaveTimerLabel.gameObject.SetActive(current < max);
}

1배와 2배 범위 제한 및 UI 전환

public const float NORMAL_TIME_SCALE = 1f;
public const float MAX_TIME_SCALE = 2f;

public void SetGameTimeScale(float value)
{
    GameTimeScale = Mathf.Clamp(value, NORMAL_TIME_SCALE, MAX_TIME_SCALE);
    Time.timeScale = GameTimeScale;
}

public void OnClick()
{
    float currentTimeScale = TimeManager.Instance.GameTimeScale;
    int nextIndex = 0;
    for (int i = 0; i < _uiDatas.Length; i++)
    {
        if (Mathf.Approximately(currentTimeScale, _uiDatas[i].Multiplier))
        {
            nextIndex = (i + 1) % _uiDatas.Length;
            break;
        }
    }

    TimeManager.Instance.GameTimeScale = _uiDatas[nextIndex].Multiplier;
    _buttonImage.sprite = _uiDatas[nextIndex].ButtonSprite;
    _contentImage.sprite = _uiDatas[nextIndex].ContentSprite;
    Time.timeScale = TimeManager.Instance.GameTimeScale;
}

Unity IAP 결과를 서버 구매 API로 전달

BuyResponse response = await ShopApiClient.BuyProductAsync(new BuyRequest
{
    CategoryName = shopCategory,
    ProductId = shopId,
    Receipt = order.Info.Receipt,
    Store = storeName,
    Arguments = args
});

if (response.Status == HttpStatusCode.OK)
{
    UIRewardPopup.ShowPopup(response.Items, response.Packmons).Forget();
}

검증 이후 보상 저장과 트랜잭션 확정

using var transaction = await _db.Database.BeginTransactionAsync();

if (payload.GachaRewardIds?.Count > 0)
{
    resultItems.AddRange(await _itemService.TakeReward(
        user, payload.GachaRewardIds, 1, false));
}

if (payload.ItemIds?.Count > 0)
{
    resultItems.AddRange(await _itemService.TakeItem(
        user,
        payload.ItemIds.Select(item => new ReqItemData(item.ItemId, item.Count)),
        false));
}

await _db.SaveChangesAsync();
await transaction.CommitAsync();