프밍노트

C# List<T>의 최적화

개발서 작성 — Sat, 20 Dec 2025 22:49:39 +0900

capacity 란 무엇인가 그리고 TrimExcess

문제의 발단

개발하던 도중c# List를 cpp Vector 리스트 초기화 처럼 괄호 내에 초기화 시켜 사용할 숫자를 넣어 사용하였습니다.

당연히 문제가 없을거라고 생각했었지만 크기 오류가 생기고 친구가 c#은 capacity 값으로 들어간다는 말을 한뒤

찾아보게 되었습니다.

그렇다면 우선 capacity란 무엇이였던 걸까요?

capacity는 메모리에 미리 할당해 두는 최대 공간의 크기라고 합니다.

그렇다면 왜? 바로 메모리 크기 대로 만들어 두는게 아니라 메모리 크기만 잡아두는것일까요?

빈공간과 데이터 를 구분할수 없어질수 있습니다.또한 쓸지 안쓸지 모르는 데이터를 미리 만든다면 너무 소비가 커질듯합니다.

데이터의 유연성 역시 중요한듯합니다.

메모리공간이 특정이상 커진다면 더큰 위치를 찾아서 넣어야 합니다.

크기만큼의 메모리 위치찾기, 데이터 복사,메모리 해제 하기

해당 작업에서 메모리를 재할당 하는것은 비싼 작업입니다.

메모리를 자주 할당 해제를 할경우 메모리 파편화가 일어날수 있습니다.

왜 연속할까?

연속되어있는 배열 과같은 데이터를 가짐으로써
연결리스트 보단 빠른 속도를 가질수 있습니다.

그렇다면 capacity 의 동작을 보겠습니다.

		 List<int> list = new List<int>();
         //처음 생성한뒤 확인
        Console.WriteLine($"The count is: {list.Count}");
        Console.WriteLine($"The capacity is: {list.Capacity}");
        list.Add(1);
        //1개 생성뒤 확인
        Console.WriteLine($"The count is: {list.Count}");
        Console.WriteLine($"The capacity is: {list.Capacity}");
        list.Add(2);
        list.Add(3);
        list.Add(4);
        Console.WriteLine($"The count is: {list.Count}");
        Console.WriteLine($"The capacity is: {list.Capacity}");
        //capacity 를 넘어섰을때 
        list.Add(5);
        Console.WriteLine($"The count is: {list.Count}");
        Console.WriteLine($"The capacity is: {list.Capacity}");

위와 같이

1부터 4까지 add로 생성뒤 count와 capcity를 확인해보면

1개 들어갔을때 capacity 4 로 늘어난뒤

capacity를 초과했을때 8로 늘어난다.

아래 처럼 확인했을경우

        List<int> lista = new List<int>(4);
        for (int i = 0; i < 30; i++)
        {
            list.Add(3);

            Console.WriteLine($"The capcitycount  is: {list.Count}");
            Console.WriteLine($"The capcitycapacity is: {list.Capacity}");
        }

4 8 16 32 64 순으로 capacity는 배수로 늘어나는걸 확인할수 있습니다.

왜 메모리 크기가 배수로 늘어날까

이는 최대한 메모리 복사가 일어날 일을 최대한 적게 하기 위함 입니다. 다른 언어나 cpp 특정 컴파일러에선

1.5배를 쓰기도 한다고 합니다.

메모리 복사가 일어나면 이전 데이터는?

cpp 의경우는 vector 에서는 비슷한 경우 move를 사용합니다. 물론 복사도 때에따라 할수있습니다.

c#의 경우 GC 가비지 에서 자동으로 처리해 주는식으로 처리합니다.

그렇다면 내가 1025개의 데이터가 필요하면 2048의 데이터 공간을 가져서

메모리가 너무 소비되어지지 않을까?

그래서 사용하지 않는 메모리 를 다시 돌려주는 함수가 있습니다.

TrimExcess() 함수는 capacity를 count에 맞게 줄여주는 역할을 하고있습니다.

동작 방식 : Count 만큼의 새 매모리를 할당하고 데이터를 모두 복사한뒤 기존의 큰 메모리를 해제

이역시 복사 생성이기때문에 난발하면 좋지않습니다.

그래서 처음 생성자에서 사용할 최대 용량을 사용하면 좋습니다.

언리얼 엔진으로 배우는 게임 디자인 패턴

개발서 작성 — Thu, 11 Dec 2025 20:52:08 +0900

오랜만에 책을 한 권 읽었습니다!.

언리얼 엔진으로 배우는 게임 디자인 패턴

책에서는 디자인 패턴을 언리얼 엔진 5에 적용 하여 사용하는 법을 알려줍니다.

시작은 언리얼 5의 블루프린트, cpp, 상속이나 변환에 관한 내용과

SOLID 원칙 같은 기본적인 부분을 먼저 잡고 넘어갑니다.

초보라면 무조건 거쳐가는 캐스케이팅 캐스트 체인 문제도 이야기해 줍니다.

위와 같이 기본적인 부분을 잡아주는 부분이 있어서 좋았습니다.

4장 전까지는 개발 공부를 해보았다면 접할수 있는 내용들을 언리얼에 맞추어 설명해주었다면

이후 부터는 언리얼5 내장되어 있는 컴포넌트,업데이트 메서드, 비헤이비어 트리 를 설명합니다.

이전 챕터들 에서 사용법을 알려주는것이 흥미로웠다면 아래부터는 이론 적인 부분을 많이 설명해줍니다.

내용중 4.2 부분에서 컴포넌트 이해 및 생성 부분도 좋았습니다.

ECS 에 관련된 내용이 잠깐 나옵니다. ECS 이기 때문에 프로그래밍의 원칙적 접근 방식을 정해주는 부분이 정말 좋은 부분인듯 합니다. 이는 쉽게 알기어렵고 알고나더라도 적용 하기 어려울수 있지만 책에선 명쾌하게 설명해주어 좋습니다.

추가 공부를 위한 정보도 간략하게 말해줍니다. 이부분은 일반적인 패턴만 설명하는 책과의 확연한 차이점인듯 합니다.

5장부터는 틱 에 대한 이야기와 델리게이트로 시작해서 설계 방식을 자연스럽게 단계적으로 설명해 줍니다.

싱글턴, 커멘드, 행동 패턴을 이용한 구조화와 패턴을 통한 최적화 들을 설명해줍니다.

최적화부분에 오브젝트 풀링 , 더티 플래그도 언리얼에서 사용한 부분을 예시로 들어주어 정말 재미있었습니다.

전반적인 내용이 초급자 보다는 중급자 가 읽기에 좋은 책인듯 합니다.

일정 이상의 언리얼, cpp를 알고있어야 이해하기 쉬울수 있습니다.

개발에 대해 충분히 이해 하지만 언리얼 공부를 하시는분이나

언리얼로 개발을 하는중 코드의 구조에 대해 고심하는분

패턴 책을 읽어 봤지만 일부 패턴을 언리얼에서 사용하는 법을 알고싶은분

위와 같은 분들이 읽기에 좋은 책인듯 합니다.

공부하시는 분들이 함수나 기능이 어떤 패턴으로 만들어졌는지 안다면 이후 개발할때 훨씬 도움 된다고 생각합니다.

저는 책을 읽은뒤 언리얼의 이해도가 높아진듯 합니다.

특히 패턴들이 언리얼에서 어떤 방식으로 사용되었는지 알수 있어서 좋았습니다.

백준 달려라 홍준 [백준:1306] 플래5

개발서 작성 — Fri, 21 Nov 2025 23:32:09 +0900

달려라 홍준아!!!
https://www.acmicpc.net/problem/1306

풀이방식

투포인터,슬라이딩 윈도우 방식으로 풀수있다.

왼쪽 i-M 부터 오른쪽 i+M 을 탐색하며 큰수가 들어오면
그수의 크기와 위치 를 기억해두고

위치가 i-M 시야에서 나가면 윈도우(i-M 부터 i+M 까지) 를 재탐색후 크기가 큰것을 찾아준다.

만약 다음 위치로 이동시 크기가 큰게 들어오면 다시 변경

현재 가장큰 light를 answer로 추가

#include<iostream>
#include <vector>
using namespace std;

void RuningHong() {
	int N, M, d, after, befor, StrongLight = 0, StrongNumber = 0;
	cin >> N >> M;
	vector<int> way(N);
	vector<int> answer;
	M--;
	for (int i = 0; i < N; ++i)
	{
		cin >> d;
		way[i] = d;
		if (i <= M + M && StrongLight <= d) {
			StrongLight = d;
			StrongNumber = i;
		}
	}
	for (int i = M; i < N - M; ++i) {
		// 시야에서 사라졌다면  다음으로 강한친구  시야에서 찾기 
		if (StrongNumber < i - M) {
			StrongLight = 0;
			StrongNumber = 0;
			for (int j = i-M; j < i + M; ++j) {
				if (StrongLight <= way[j]) {
					StrongLight = way[j];
					StrongNumber = j;
				}
			}
		}
		//|| 다음으로 들어온게 현재꺼 보다 크다면 바꿔주기
		if (StrongLight <= way[i + M]) {
			StrongLight = way[i + M];
			StrongNumber = i;
		}
		answer.push_back(StrongLight);

	}

	for (auto data : answer) {
		cout << data << " ";
	}

}

int main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(0);
	std::cout.tie(0);
	RuningHong();
}

K번째 최단경로 찾기 [백준:1854] 플래4

개발서 작성 — Tue, 16 Sep 2025 15:32:54 +0900

K번째 최단경로를 찾는 문제

사용했던 경로를 제거했던 거의 최단경로 와 비슷하다고 생각했지만.

해당 문제는 사용했던 경로 까지 생각해서 K째 경로를 찾는 문제다.

문제 풀이방법은

BFS 로 우선순위는 거리가 적게 이동한 순서로 우선순위 큐를 만들어준다.

만약 아직 이동 cost가 K 번째가 아니라면 BFS로 이동을 해준다.

최우선 거리를 먼저 실행하기에 도착했을때 몇번째로 도착했는지만 알수있다면 끝난다.

그렇게 모든노드를 K번째 방문했을때 BFS를 끝내주면 된다.

#include<iostream>
#include<vector>
#include<unordered_map>
#include<queue>
using namespace std;

void K_MST() {
	unordered_map<int, unordered_map<int, int>> KMap;
	unordered_map<int, unordered_map<int, int>> K_reverse_Map;
	// 0 = 최단거리 , 1= 그전 노드 , 2 = k번째 횟수
	unordered_map<int, tuple<int, int, int>> Visit_trunk_Map;
	int N, M, K, a, b, c;
	cin >> N >> M >> K;

	for (int i = 0; i < M; ++i) {
		cin >> a >> b >> c;
		KMap[a][b] = c;
		K_reverse_Map[b][a] = c;
	}
	for (int i = 0; i < N; ++i) {
		Visit_trunk_Map[i + 1] = { 2147483646 ,-1,K };
		//   3번째는 이전노드  마지막은 k를구할 이동횟수
	}
	
	
	priority_queue<tuple<int, int, int>> PQ;
	PQ.push({ 0, 1,0 });


	//K번째 도착해야하는 노드의 갯수
	int NNum = N;
	
	while (NNum != 0 && !PQ.empty())
	{
		//first = 거리cost , second = 현재 노드 thread = 전노드
		auto data = PQ.top();
		PQ.pop();
		// k가 작으면 k-1

		//현재 노드에 도착했다는 것이기에  현재 노드가 몇번째 도착인지 카운트
		if (get<2>(Visit_trunk_Map[get<1>(data)]) > 0) {

			// 현재 몇번째 도착했는지 저장
			Visit_trunk_Map[get<1>(data)] = { -get<0>(data),get<1>(data),get<2>(Visit_trunk_Map[get<1>(data)]) - 1 };
			
			// 만약 이번이 마지막 도착이였을경우 현재노드는 K번째로 도착했기에 끝
			if (0 == get<2>(Visit_trunk_Map[get<1>(data)])) {
				NNum--;
			}
		}
		else {
			continue;
		}
		//현재 노드에서 갈수있는 노드 재탐색
		for (auto Ks : KMap[get<1>(data)]) {
			// 거리 이동, 다음실행시 현재노드 , 다음실행시 전노드
			PQ.push({ -(-get<0>(data) + Ks.second),Ks.first,get<1>(data) });
		}
	}

	//노드들을 실행하며 최단거리 확인
	for (int i = 1; i <= N; ++i) {
		int  answer = 2147483646;
		answer = get<0>(Visit_trunk_Map[i]);
		if (answer == 2147483646 || get<2>(Visit_trunk_Map[i]) != 0)answer = -1;
		cout << answer << "\n";

	}

}
int main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(0);
	std::cout.tie(0);
	K_MST();

	return 0;
}

위처럼 만들었지만

블로그를 쓰면서 메모리를 조금더 아낄수 있는 방법이 있었다

정말간단하게 방문할 코드중 이미 끝난 코드는 방문하지 않는방법이다.

		for (auto Ks : KMap[get<1>(data)]) {
			
			//다음노드가 끝났으면 갈 필요 없음
			if (0 != get<2>(Visit_trunk_Map[Ks.first])) {
				// 거리 이동, 다음실행시 현재노드 , 다음실행시 전노드
				PQ.push({ -(-get<0>(data) + Ks.second),Ks.first,get<1>(data) });
			}
		}

그러면

처럼 줄어든다

#include<iostream>
#include<vector>
#include<unordered_map>
#include<queue>
using namespace std;

void K_MST() {
	unordered_map<int, unordered_map<int, int>> KMap;
	unordered_map<int, unordered_map<int, int>> K_reverse_Map;
	// 0 = 최단거리 , 1= 그전 노드 , 2 = k번째 횟수
	unordered_map<int, tuple<int, int, int>> Visit_trunk_Map;
	int N, M, K, a, b, c;
	cin >> N >> M >> K;

	for (int i = 0; i < M; ++i) {
		cin >> a >> b >> c;
		KMap[a][b] = c;
		K_reverse_Map[b][a] = c;
	}
	for (int i = 0; i < N; ++i) {
		Visit_trunk_Map[i + 1] = { 2147483646 ,-1,K };
		//   3번째는 이전노드  마지막은 k를구할 이동횟수
	}
	
	
	priority_queue<tuple<int, int, int>> PQ;
	PQ.push({ 0, 1,0 });


	//K번째 도착해야하는 노드의 갯수
	int NNum = N;
	
	while (NNum != 0 && !PQ.empty())
	{
		//first = 거리cost , second = 현재 노드 thread = 전노드
		auto data = PQ.top();
		PQ.pop();
		// k가 작으면 k-1

		//현재 노드에 도착했다는 것이기에  현재 노드가 몇번째 도착인지 카운트
		if (get<2>(Visit_trunk_Map[get<1>(data)]) > 0) {

			// 현재 몇번째 도착했는지 저장
			Visit_trunk_Map[get<1>(data)] = { -get<0>(data),get<1>(data),get<2>(Visit_trunk_Map[get<1>(data)]) - 1 };
			
			// 만약 이번이 마지막 도착이였을경우 현재노드는 K번째로 도착했기에 끝
			if (0 == get<2>(Visit_trunk_Map[get<1>(data)])) {
				NNum--;
			}
		}
		else {
			continue;
		}
		//현재 노드에서 갈수있는 노드 재탐색
		for (auto Ks : KMap[get<1>(data)]) {
			
			//다음노드가 끝났으면 갈 필요 없음
			if (0 != get<2>(Visit_trunk_Map[Ks.first])) {
				// 거리 이동, 다음실행시 현재노드 , 다음실행시 전노드
				PQ.push({ -(-get<0>(data) + Ks.second),Ks.first,get<1>(data) });
			}
		}
	}

	//노드들을 실행하며 최단거리 확인
	for (int i = 1; i <= N; ++i) {
		int  answer = 2147483646;
		answer = get<0>(Visit_trunk_Map[i]);
		if (answer == 2147483646 || get<2>(Visit_trunk_Map[i]) != 0)answer = -1;
		cout << answer << "\n";

	}

}
int main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(0);
	std::cout.tie(0);
	K_MST();

	return 0;
}

데바데 블러드웹 만들어보기

개발서 작성 — Wed, 10 Sep 2025 17:21:05 +0900

데바데 자동 구매는 어떤 방법일까? 해서 심심해서 비슷하게 구현해보았다.

데드바이 데이라이트를 플레이하던 중 게임에는 아래와 같이

아이템을 구매하는 시스템이 존재한다.

해당 페이지의 중앙 버튼은 아이템을 자동으로 구입해 주는 시스템인데 아무 생각 없이 보고 있다 문득

해당 페이지에서 사용하는 알고리즘이 무엇인지 궁금해졌다

처음 문득 생각했을 때는 다익스트라 또는 최소 스패닝트리를 사용했을 거 같았다.

당연하게도 전체적으로 가장 저렴한 루트를 제공할 것이라고 생각했기 때문이다.

알고리즘을 분석하기위해 자동 구매를 하며 영상녹화 한 뒤

분석하던 도중 이상한 순서로 구매하는 것을 확인하고 의문이 들어서 찾던 중 아래와 같은 사실을 확인해 버렸다.

깊이가 가까운 노드에서 가격이 저렴한 순서대로 샀다는 것이다.

그렇다는 건

가깝고 싼 순서부터 우선순위 더 싸더라도 한 칸이라도 멀리 있으면 비싼 걸 구매한다.

무서운 진실(최대한 싸게 구매하지 않는다는) 사실을 알아버렸지만 좌절하고 있을 수는 없다.

계속 분석해보자

배치는 어떤 식일까?

그렇다면 배치는 어떤 식으로 만들어지는지 자세히 보기 위해 좀 더 많은 배치가 있는 화면을 들고 와보았다.

자~세하게 본다면 미리 배치가 일정 정해져 있는 것을 볼 수 있다.

RootNode

Depth 1 노드수 6개

Depth 2 노드수 12개

Depth 3 노드수 12개

깊이에 비례해서 노드수가 커지지는 않는 것 같다.

간선은

RootNode = Depth 1 간선 6개

Depth 1 = Root Node + 같은 Depth 간선 최대 2개 + Depth +1 간선 2개

Depth 2 = Depth 1 간선 최대 2개 + 같은 Depth 간선 최대 2개 + Depth +1 간선 2개

Depth 3 = Depth 2 간선 최대 2개 + 같은 Depth 간선 최대 2개

정도로 보인다.

해당 시스템을 그대로 만든다면
미리 노드들과 위치 연결된 간선을 만들어둔 뒤

root 노드에서 BFS 나 DFS로 만 들것 같다.

하지만 아이템 등장 확률이나 간선 노드 생성 수식을 모르니

임시로 만들어보았다.

3개의 깊이로 2번 3번에서는 왼쪽과 아래 간선을 랜덤 하게 연결하는 식으로 만들었다.

깊이당 노드도 랜덤이기에

큰 기획 없이 랜덤 하게 스폰하게 만든 간단한 그래프기에

더 외부의 그래프의 노드가 적다면

간선끼리 겹치거나 이미지 뒤로 겹치는 경우도 존재한다.

생성 후 가까운 노드에 연결하는 방식도 생각해 보았지만

우선 대부분은 큰 문제가 없기 때문에 이후 수정하는 것으로 하자.

아래는 잘 나온 그래프.

간선이 겹치는 경우

이제 데바데의 형식으로 먹는 것을 계산해 보자

우선 아이템만 존재할 때 먹는 걸 만들었다.

https://youtu.be/SVtNEP8hgnE

https://youtu.be/WlBpLT75-48

https://youtu.be/50XT6vks62Q

using NUnit.Framework;
using System.Collections.Generic;
using UnityEngine;
using System.Linq;
using System;
using Unity.VisualScripting;
using UnityEngine.UI;
using System.Net;
using System.Collections;

public class BloodwebSystem : MonoBehaviour
{

    private PriorityQueue<(int, ItemScriptableObject), (int, int)> queue;
    private ItemScriptableObject RootItems;
    private Dictionary<int, List<LineRenderer>> lineRenderers = new Dictionary<int, List<LineRenderer>>();
    private Dictionary<(int, int), LineRenderer> EdgeDicrionaty = new Dictionary<(int, int), LineRenderer>();

    private Queue<int> Deadny_Auto = new Queue<int>();
    private List<bool> Deadny_ison;
    //아이템리스트
    public List<ItemScriptableObject> PabItems;
    private List<ItemScriptableObject> ItemList = new List<ItemScriptableObject>();
    // ui 생성위치
    public GameObject MakeBloodwebPoint;
    public GameObject MakeBloodwebLinePoint;
    //깊이당 생성 저장
    public List<List<ItemScriptableObject>> BloodwebDepth;

    public GameObject BloodObjectPrefab;


    public GameObject BloodObjectLinePrefab;


    [SerializeField, UnityEngine.Range(1, 30)]
    public int MaxPoint = 25;
    public int MaxPath = 25;


    [SerializeField, UnityEngine.Range(1, 100)]
    public int CircleRadius = 25;


    private List<(int, int)> DijkstraInts = new List<(int, int)>(), DBDSerchInts = new List<(int, int)>(), SmallSerchInts = new List<(int, int)>();

    // 데이터 시트 구현
    void Start()
    {

        Init();
        //queue = new PriorityQueue<ItemScriptableObject, (int, int)>();
        //queue.Enqueue(new ItemScriptableObject { price = 3 }, (0, 1000));
        //queue.Enqueue(new ItemScriptableObject { price = 1 }, (-1, 2000));
        //queue.Enqueue(new ItemScriptableObject { price = 2 }, (-1, 3000));
        //queue.Enqueue(new ItemScriptableObject { price = 4 }, (1, -2000));
        //queue.Enqueue(new ItemScriptableObject { price = 5 }, (2, 0));

        //while (queue.Count > 0)
        //{
        //    Debug.Log(queue.Dequeue().price);
        //}

    }
    //가격순 정렬
    int compareItem(ItemScriptableObject a, ItemScriptableObject b)
    {
        return a.price < b.price ? -1 : 1;
    }

    private void Init()
    {
        //3개의 뎁스
        queue = new PriorityQueue<(int, ItemScriptableObject), (int, int)>();
        BloodwebDepth = new List<List<ItemScriptableObject>>(3);
        RootItems = new ItemScriptableObject { price = -1, edge = new List<ItemScriptableObject>() };
        //PabItems 갑어치에 따른 정렬
        PabItems.Sort(compareItem);


        int min = 8;
        int max = 12;

        int number = 0;

        for (int i = 0; i < 3; ++i)
        {
            BloodwebDepth.Add(new List<ItemScriptableObject>());

            float randomValue = UnityEngine.Random.Range(0f, 1f);
            float bias = 2f + i;
            int selectedValue = Mathf.FloorToInt(min + Mathf.Pow(randomValue, bias) * (max - min + 1));

            if (i == 0)
            {
                selectedValue = 6;
            }
            for (int j = 0; j < selectedValue; ++j)
            {

                int R_Number = UnityEngine.Random.Range(0, PabItems.Count);
                //가치에 따른 낮은 확율 생성 필요
                ItemScriptableObject tempI = new ItemScriptableObject
                {
                    numbering = number,
                    price = PabItems[R_Number].price,
                    Sprite = PabItems[R_Number].Sprite,
                    depth = i,
                    edge = new List<ItemScriptableObject>()
                };
                lineRenderers.Add(number, new List<LineRenderer>());

                number++;
                BloodwebDepth[i].Add(tempI);
                ItemList.Add(tempI);



            }
        }

        (int, int)[] edges = { (-1, 0), (0, -1) };
        DrawBloodWeb();

        for (int i = 0; i < BloodwebDepth.Count; ++i)
        {
            for (int j = 0; j < BloodwebDepth[i].Count; ++j)
            {
                if (i == 0)
                {
                    RootItems.edge.Add(BloodwebDepth[i][j]);


                    var d = DrawLine(MakeBloodwebLinePoint.transform.position, BloodwebDepth[i][j].g.transform.position);
                    EdgeDicrionaty.Add((-1, j), d);

                    //옆라인 연결 있든없든 상관없음 
                }
                else
                {
                    int numToSelect = UnityEngine.Random.Range(1, edges.Length + 1);
                    bool[] selectedFlags = new bool[edges.Length];

                    while (BloodwebDepth[i][j].edge.Count < numToSelect)
                    {
                        int randomIndex = UnityEngine.Random.Range(0, edges.Length);

                        // 이미 선택된 항목인지 확인
                        if (!selectedFlags[randomIndex])
                        {
                            int TDepth = i + (edges[randomIndex].Item1);
                            int whith = j + edges[randomIndex].Item2;


                            if (whith < 0) whith = BloodwebDepth[i].Count - 1;
                            if (BloodwebDepth[TDepth].Count - 1 < whith) whith = (BloodwebDepth[TDepth].Count - 1) % whith;
                            if (BloodwebDepth[TDepth][whith]) selectedFlags[randomIndex] = true;

                            BloodwebDepth[i][j].edge.Add(BloodwebDepth[TDepth][(whith)]);
                            BloodwebDepth[TDepth][whith].edge.Add(BloodwebDepth[i][j]);

                            var d = DrawLine(BloodwebDepth[i][j].g.transform.position, BloodwebDepth[TDepth][whith].g.transform.position);
                            lineRenderers[BloodwebDepth[i][j].numbering].Add(d);
                            lineRenderers[BloodwebDepth[TDepth][whith].numbering].Add(d);
                            EdgeDicrionaty.Add((BloodwebDepth[i][j].numbering, BloodwebDepth[TDepth][whith].numbering), d);
                            EdgeDicrionaty.Add((BloodwebDepth[TDepth][whith].numbering, BloodwebDepth[i][j].numbering), d);
                        }
                    }
                }
            }
        }

        Debug.Log("end");
        //미리 계산하기
        Deadny_Auto = Deadny_AutoChoiceAll();
        Deadny_AutoDraw(Deadny_Auto);

        //DBDSerchInts = DbdDirections();
        //DijkstraInts = DijkstraAll();
        SmallSerchInts = SmallerDirections();

        //StartCoroutine(drawingColor(DBDSerchInts));
        //StartCoroutine(drawingColor(DijkstraInts));
        StartCoroutine(drawingColor(SmallSerchInts));

    }


    private LineRenderer DrawLine(Vector3 x, Vector3 y)
    {

        GameObject lineObject = Instantiate(BloodObjectLinePrefab, MakeBloodwebLinePoint.transform);
        LineRenderer lr = lineObject.GetComponent<LineRenderer>();
        lr.SetPosition(0, x);
        lr.SetPosition(1, y);
        lr.sortingOrder = -1;
        return lr;
    }
    private void DrawBloodWeb()
    {
        Vector3 UITransformPosition = MakeBloodwebPoint.transform.position;

        for (int i = 0; i < BloodwebDepth.Count; i++)
        {

            float CircleRate = (CircleRadius * 0.1f) * (i + 1);
            int count = BloodwebDepth[i].Count;
            for (int j = 0; j < BloodwebDepth[i].Count; j++)
            {
                float theta = (2 * MathF.PI / count) * j;
                var data = BloodwebDepth[i][j];
                data.position.x = UITransformPosition.x + CircleRate * MathF.Cos(theta);
                data.position.y = UITransformPosition.y + CircleRate * MathF.Sin(theta);
                Vector3 ObjectTransformPosition = new Vector3(data.position.x, data.position.y, 0);


                GameObject G = Instantiate(BloodObjectPrefab, MakeBloodwebPoint.transform);
                G.transform.position = ObjectTransformPosition;
                G.GetComponent<Image>().sprite = BloodwebDepth[i][j].Sprite;
                BloodwebDepth[i][j].g = G;

            }
        }
    }
    public Queue<int> Deadny_AutoChoiceAll()
    {
        Deadny_ison = new List<bool>(ItemList.Count + 1);
        for (int i = 0; i < ItemList.Count + 1; ++i)
        {
            Deadny_ison.Add(false);
        }
        Queue<int> temp = new Queue<int>();
        queue.Enqueue((0, RootItems), (0, 0));
        while (queue.Count > 0)
        {
            (int, ItemScriptableObject) data = queue.Dequeue();
            int num = data.Item1;
            if (data.Item2.numbering != -1)
            {
                temp.Enqueue(data.Item2.numbering);
                Deadny_ison[data.Item2.numbering] = true;
            }
            foreach (var edge in data.Item2.edge)
            {
                if (Deadny_ison[edge.numbering] == false)
                {
                    queue.Enqueue((num + edge.price, edge), (edge.depth, num + edge.price));
                }
            }
        }
        return temp;
    }
    public void Deadny_AutoDraw(Queue<int> deadny_Auto)
    {
        while (deadny_Auto.Count > 0)
        {
            int num = deadny_Auto.Dequeue();
            ItemList[num].g.GetComponent<Button>().image.color = new Color(144, 55, 55);
            Debug.Log(ItemList[num].g.GetComponent<Image>().sprite);

        }
    }

    public void NodeNtoChangeColor(int BaseNodeNumber, int ChangeNodeNumber, Color EdgeColor, Color ItemColor)
    {
        EdgeDicrionaty[(BaseNodeNumber, ChangeNodeNumber)].startColor = EdgeColor;
        EdgeDicrionaty[(BaseNodeNumber, ChangeNodeNumber)].endColor = EdgeColor;
        ItemList[ChangeNodeNumber].g.GetComponent<Button>().image.color = (ItemColor);
    }


    private IEnumerator drawingColor(List<(int,int)>Ints)
    {
        foreach ((int, int) d in Ints)
        {
            Debug.Log(d);
            NodeNtoChangeColor(d.Item1, d.Item2, Color.green, Color.black);
            yield return new WaitForSeconds(1f);

        }
    }



    //이후 탐색클래스 분리
    public List<(int, int)> DijkstraAll()
    {
        List<(int, int)> list = new List<(int, int)>();
        PriorityQueue<(ItemScriptableObject, int, int), (int, int)> dijksqueue = new PriorityQueue<(ItemScriptableObject, int, int), (int, int)>();
        dijksqueue.Enqueue((RootItems, -1, 0), (0, 0));
        List<bool> complete = new List<bool>();
        foreach (ItemScriptableObject item in ItemList)
        {
            complete.Add(false);
        }

        while (dijksqueue.Count != 0)
        {

            var data = dijksqueue.Dequeue();
            Debug.Log(data.Item1.numbering);

            if (data.Item1.numbering != -1)
            {
                if (complete[data.Item1.numbering] == true) continue;
                list.Add((data.Item2, data.Item1.numbering));
                complete[data.Item1.numbering] = true;

            }
            foreach (var edge in data.Item1.edge)
            {
                int dijkcost = edge.price + data.Item3;
                if (complete[edge.numbering] == true) continue;

                dijksqueue.Enqueue((edge, data.Item1.numbering, dijkcost), (dijkcost, 0));
            }
        }
        return list;
    }

    public List<(int, int)> SmallerDirections()
    {
        List<(int, int)> list = new List<(int, int)>();
        PriorityQueue<(ItemScriptableObject, int, int), (int, int)> dijksqueue = new PriorityQueue<(ItemScriptableObject, int, int), (int, int)>();
        dijksqueue.Enqueue((RootItems, -1, 0), (0, 0));
        List<bool> complete = new List<bool>();
        foreach (ItemScriptableObject item in ItemList)
        {
            complete.Add(false);
        }

        while (dijksqueue.Count != 0)
        {

            var data = dijksqueue.Dequeue();
            Debug.Log(data.Item1.numbering);

            if (data.Item1.numbering != -1)
            {
                if (complete[data.Item1.numbering] == true) continue;
                list.Add((data.Item2, data.Item1.numbering));
                complete[data.Item1.numbering] = true;

            }
            foreach (var edge in data.Item1.edge)
            {
                int dijkcost = edge.price + data.Item3;
                if (complete[edge.numbering] == true) continue;

                dijksqueue.Enqueue((edge, data.Item1.numbering, dijkcost), (edge.price, 0));
            }
        }
        return list;
    }
    public List<(int, int)> DbdDirections()
    {
        List<(int, int)> list = new List<(int, int)>();
        PriorityQueue<(ItemScriptableObject, int, int), (int, int)> dijksqueue = new PriorityQueue<(ItemScriptableObject, int, int), (int, int)>();
        dijksqueue.Enqueue((RootItems, -1, 0), (0, 0));
        List<bool> complete = new List<bool>();
        foreach (ItemScriptableObject item in ItemList)
        {
            complete.Add(false);
        }

        while (dijksqueue.Count != 0)
        {

            var data = dijksqueue.Dequeue();
            Debug.Log(data.Item1.depth);

            if (data.Item1.numbering != -1)
            {
                if (complete[data.Item1.numbering] == true) continue;
                list.Add((data.Item2, data.Item1.numbering));
                complete[data.Item1.numbering] = true;

            }
            foreach (var edge in data.Item1.edge)
            {
                int dijkcost = edge.price + data.Item3;
                if (complete[edge.numbering] == true) continue;

                dijksqueue.Enqueue((edge, data.Item1.numbering, dijkcost), (edge.depth, edge.price));
            }
        }
        return list;
    }
}

이후 추가 예정.

간선 겹침 해결

이후 아이템 노드 잠김
잠기는 노드에 따른 최적치 계산

AI로 격투게임 만들기 1.(AI로 애니메이션 뽑기)

개발서 작성 — Mon, 28 Apr 2025 15:05:38 +0900

20250417

AI 쌀먹 하는 여인들

캐릭터가 제대로 뽑아지는지 테스트 해보자 이펙트역시 뽑아볼것

우선 할것 stablediffusion web ui 세팅

파이썬0250417

캐릭터가 제대로 뽑아지는지 테스트 해보자 이펙트역시 뽑아볼것

영상이 설명을 잘해준다 영상을 보고 하는게 빠르겠지만 그냥 서술해본다.

참고 할것 들

https://youtu.be/rZClOQlHqcA

https://youtu.be/Ffl8b_GfJ-M

https://www.youtube.com/watch?v=V1VWLRZBz5c

우선 할것 stablediffusion web ui 세팅

파이썬 버전 3.10.11 설치

가상환경 시스템 venv

venv란? 파이썬에서 제공하는 라이브러리 가상공간 이라고 생각하면 된다.

아나콘다 처럼 가상의 공간을 할당하여

파이썬 프로젝트 끼리 필요한 라이브러리가 충돌나지않게 관리해주며

한번에 관리하기에 설정하기도 편리하다

만약 파일위치를 바꿔서 실행이 안된다거나 파일위치를 변경해줘야한다면

venv 파일내의 라이브러리 위치 설정을 다시설정해줘야

프로젝트 파일위치 C:\python\2dCreateAnime

가상환경 만들기 python -m venv 이름(venv)

접속 (이름)venv\Scripts\activate

# 가상 환경을 비활성화하는 코드 deactivate

가상환경 세팅 txt로 뽑는법

pip freeze > requirements.txt

다운로드법

pip install -r requirements.txt

아래 깃허브를 설치 해준다

Forge GitHub
https://github.com/lllyasviel/stable-diffusion-webui-forge

GitHub - lllyasviel/stable-diffusion-webui-forge

Contribute to lllyasviel/stable-diffusion-webui-forge development by creating an account on GitHub.

github.com

git clone https://github.com/lllyasviel/stable-diffusion-webui-forge
cd stable-diffusion-webui-forge
python launch.py --xformers

아래 파일을 통해 라이브러리를 설치해준다.

파일위치로 이동한뒤

pip install -r requirements_versions.txt

실행하여 라이브러리 설치

stable-diffusion의 모델을 설치해준다.

https://huggingface.co/Comfy-Org/stable-diffusion-v1-5-archive/tree/main

Comfy-Org/stable-diffusion-v1-5-archive at main

huggingface.co

C:\python\2dCreateAnime\stable-diffusion-webui-forge\models\Stable-diffusion\ 위치에 다운로드 후 다시실행

시작시 아래 화면을 볼수있다.

local url이 활성화 되어서 http://127.0.0.1:7860 (로컬호스트)

로 열린다.

이제 우리가 잘아는 화면이 나온다.

forge의 문제 때문에 특정 모델 로드 실패로 인해 sampling method 의 몇가지가 실행 하지못했다.

버전 변경을 하다가 에러가 난뒤 꼬인듯하여 재설치 하였다.

가정한 경로 정보

Web UI 폴더 위치: C:\python\2dCreateAnime\stable-diffusion-webui-forge
가상환경 이름: venv
실행할 스크립트: launch.py

▶ start.bat 내용

@echo off
cd /d C:\python\2dCreateAnime\stable-diffusion-webui-forge
call venv\Scripts\activate
python launch.py --xformers
pause

# 새로 클론
cd C:\python\2dCreateAnime
git clone https://github.com/lllyasviel/stable-diffusion-webui-forge.git

# venv 새로 생성
python -m venv venv
venv\Scripts\activate

#venv 관련 항목 설치
cd stable-diffusion-webui-forge
pip install -r requirements.txt

cuda pytorch가 gpu와 호환문제

RuntimeError: Your device does not support the current version of Torch/CUDA!

pip install torch==2.1.2 torchvision==0.16.2 --index-url https://download.pytorch.org/whl/cu121

해당에러 발견

(xformers 의 호환성 에러)

해결을 위해 재설치

pip uninstall xformers -y

pip install torch==2.1.2 torchvision==0.16.2 --index-url https://download.pytorch.org/whl/cu121

pip install xformers==0.0.23.post1

이제 전부 완료되어서 잘나온다.

https://civitai.com/models/165876/2d-pixel-toolkit-2d

2D Pixel Toolkit (2D像素工具包) - Sprites_64 | Stable Diffusion LoRA | Civitai

QQ交流群753289747，群内会不时发布内测模型我的游戏已上线Steam商店页面，求求各位大佬加个愿望单~↓↓↓↓↓ My game has been launched on Steam! Wishlist it now if you're interested! ❤️↓↓↓↓↓ Stea...

civitai.com

해당 모델을 다운받아 로라 파일에 저장 하면

C:\python\2dCreateAnime\stable-diffusion-webui-forge\models\Lora

아래 이미지처럼 Lora에 pixel sprites 항목이 추가된다.

해당 항목을 누르면 prompt에 <lora:pixel sprites:1> 가 추가되면서 설정을 추가할수있다.

또한 해당 설정을 더 잘사용하기위해 추천모델들이 존재한다.

https://civitai.com/models/23900/anylora-checkpoint?modelVersionId=95489

AnyLoRA - Checkpoint - bakedVae (blessed) fp16 NOT-PRUNED | Stable Diffusion Checkpoint | Civitai

AnyLoRA Add a ❤️ to receive future updates. Do you like what I do? Consider supporting me on Patreon ️ or feel free to buy me a coffee ☕ For LCM rea...

civitai.com

C:\python\2dCreateAnime\stable-diffusion-webui-forge\models\Stable-diffusion 에추가하면

위의 Chekpoint 에 새로운 항목을 추가할수 있다.

그리고는 프롬프트와 설정들을 만져주면 위와같은 깔끔한 도트를 얻을수있다.

2d의 포즈를 얻기위해서는

ControlNet Integrated 설정이 필요한데 해당설정은 다음글에서

백조의 호수[백준:3197]플래티넘5

개발서 작성 — Tue, 11 Mar 2025 18:44:12 +0900

https://www.acmicpc.net/problem/3197

위 이미지처럼

X = 얼음

. = 호수

L = 백조

하루마다 호수에 맞닿아 있는 얼음이 녹는다.

백조는 며칠뒤에 서로 만날 수 있을지 구하는 문제이다.

여기 주소에서 데이터를 받아볼수있다.

https://hsin.hr/2005/

문제 풀이에 사용한 알고리즘은

BFS , UnionFind 두개다

문제는 아래 두가지 라고 생각했다.

1.얼음을 녹일 방법

2.백조가 만날수 있는지 확인할수 있는 방법

해결방식

1.얼음의 외각을 녹일때 다음 녹을 얼음을 지정해 큐에 넣어준다.

2.얼음마다 지역을 설정해둔뒤 다른지역과 합쳐질때 서로 합쳐준다.

코드

#include<iostream>
#include <queue>
using namespace std;
vector<pair< int, int>> Swans;
queue<pair<int, int>> X_queue, TempQueue, * PointerQueue, * TempPointerQueue;
const static vector < vector<int>> Mover{ {1,0},{0,1},{-1,0},{0,-1} };
const static vector < vector<int>> InputMover{ {0,-1},{-1,0} };
vector<int> lakeList;

int UnionFInd(int Num) {
	if (lakeList[Num] == Num)
		return Num;
	return lakeList[Num] = UnionFInd(lakeList[Num]);
}

void Union(int Left, int Right) {
	int LNum = UnionFInd(Left);
	int RNum = UnionFInd(Right);
	if (LNum == RNum)return;
	if (LNum > RNum) {
		lakeList[LNum] = RNum;
	}
	else {
		lakeList[RNum] = LNum;
	}
}
enum Tile
{
	X = -88,
	x = -120,
	L = -76,
	dot = -46
};
void SwanLake() {
	int R, C;
	cin >> R >> C;
	vector<vector<int>> lake(R, vector<int>(C));
	vector< int> L_Point(2);
	int numb = 1;
	lakeList.push_back(0);
	for (int i = 0; i < R; ++i) {
		for (int j = 0; j < C; ++j) {
			char chardata;
			cin >> chardata;
			lake[i][j] = -(int)chardata;
			if (chardata == 'L') Swans.push_back({ i,j });
			int after = -1, before = -1;

			for (auto M : InputMover) {
				if (0 > i + M[0] || 0 > j + M[1] || R <= i + M[0] || C <= j + M[1])continue;
				if ((lake[i][j] == Tile::dot || lake[i][j] == Tile::L) && lake[i + M[0]][j + M[1]] == Tile::X) {
					X_queue.push({ i + M[0],j + M[1] });
					lake[i + M[0]][j + M[1]] = Tile::x;
				}
				if (lake[i][j] == Tile::X && lake[i + M[0]][j + M[1]] > 0) {
					X_queue.push({ i,j });
					lake[i][j] = Tile::x;
				}

				if ((lake[i][j] == Tile::dot || lake[i][j] == Tile::L) && lake[i + M[0]][j + M[1]] > 0) {
					if (after == -1) {
						after = lake[i + M[0]][j + M[1]];
					}
					else {
						before = lake[i + M[0]][j + M[1]];
					}

				}
			}
			if ((lake[i][j] == Tile::dot || lake[i][j] == Tile::L)) {
				if (after == -1) {
					lake[i][j] = numb;
					lakeList.push_back(numb++);

				}
				else if (before == -1) {
					lake[i][j] = after;
				}
				else {
					Union(after, before);
					lake[i][j] = UnionFInd(after);
				}
			}


		}
	}

	for (int i = 0; i < 2; ++i) {
		L_Point[i] = (lake[Swans[i].first][Swans[i].second]);
	}
	int day = 0;
	if (UnionFInd(L_Point[0]) == UnionFInd(L_Point[1])) {
		cout << day;
		return;
	}


	do {
		day++;
		PointerQueue = &((X_queue.empty()) ? TempQueue : X_queue);
		TempPointerQueue = &((!X_queue.empty()) ? TempQueue : X_queue);
		while (!PointerQueue->empty())
		{
			auto data = PointerQueue->front();
			PointerQueue->pop();
			int Isbridge = 0;
			int firstbridge = -1, secondbridge = -1;

			for (auto M : Mover) {
				if (0 > data.first + M[0] || 0 > data.second + M[1] || R <= data.first + M[0] || C <= data.second + M[1])continue;
				if (lake[data.first + M[0]][data.second + M[1]] == Tile::X)
				{
					lake[data.first + M[0]][data.second + M[1]] = Tile::x;
					TempPointerQueue->push({ data.first + M[0] ,data.second + M[1] });
				}
				else if (lake[data.first + M[0]][data.second + M[1]] >= 0) {

					if (Isbridge != 0) {
						Union(lake[data.first][data.second], lake[data.first + M[0]][data.second + M[1]]);
					}
					else {
						Isbridge = lake[data.first + M[0]][data.second + M[1]];
						lake[data.first][data.second] = Isbridge;
					}
				}
			}
		}

		if (UnionFInd(L_Point[0]) == UnionFInd(L_Point[1]))break;


	} while (!TempPointerQueue->empty());
	cout << day;
}



int main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(0);
	std::cout.tie(0);
	SwanLake();

}

어른상어 [백준:19237]골드

개발서 작성 — Fri, 20 Dec 2024 01:41:54 +0900

으른 상어

https://www.acmicpc.net/problem/19237

문제의 구조는

입력받기

상어의 이동 방향 데이터 받아오기

상어의 이동

상어의 냄새 남기기

순서로 진행한다.

위이미지처럼 1번 상어부터

오른쪽을 보기에 맨 아래 오른쪽 왼쪽 위아래 순으로 탐색한다.

냄새를 남긴다.

만약 겹칠 경우 낮은 값을 가진 상어가 이긴다.

해당 문제를 해결할 때 냄새를 업데이트한다면 시간이 많이 걸릴 것이라 생각했기에 time으로 그냥 계산해 준다.

해당 문제에서 26 퍼에서 틀린다면 1000 이상 인지 초과인지 개발 순서의 시간을 언제 업데이트

하는지 확인해야 한다.

#include<iostream>
#include<vector>

using namespace std;
static const int SharkBasic_Mover[4][2] = { {0,-1} ,{0,1}, {-1,0}, {1,0} };
enum direction {
	UP = 0,
	DOWN,
	LEFT,
	RIGHT
};
struct Shark
{
public:
	Shark() {
		Mover = vector<vector<direction>>(4, vector<direction>(4));
		Sharknumber = -1;
		PosX = -1, PosY = -1;
	}

	vector<vector<direction>> Mover;
	direction dir;
	int PosX, PosY, Sharknumber;
	bool IS_Alive = true;
};

void AdultShark() {
	//N*N , M개상어, K냄새 남는시간
	int N = 0, M = 0, K = 0, time = 0;
	//현재시간과 비교해서 사라졌는지 확인
	cin >> N >> M >> K;
	vector< Shark>Sharks(M, Shark());
	vector<vector<pair<int, int>>> World(N, vector<pair<int, int>>(N, make_pair(-1, -1)));
	int num = 0;
	for (int i = 0; i < N; ++i) {
		for (int j = 0; j < N; ++j) {
			cin >> num;
			if (num != 0) {
				Sharks[num - 1].PosX = j;
				Sharks[num - 1].PosY = i;
				Sharks[num - 1].Sharknumber = num - 1;
				World[j][i] = make_pair(num - 1, time);

			}
		}
	}
	//상어방향
	for (int i = 0; i < M; ++i) {
		cin >> num;
		Sharks[i].dir = direction(num - 1);
	}
	//방향우선순위
	for (int i = 0; i < M; ++i) {
		for (int j = 0; j < 4; ++j) {
			for (int k = 0; k < 4; ++k) {
				cin >> num;
				Sharks[i].Mover[j][k] = direction(num - 1);
			}
		}
	}
	vector<direction>* MoveDir;
	int x = 0, y = 0;
	while (M != 1)
	{
		time++;
		//이동할 위치 넣기
		for (Shark& S : Sharks) {
			if (S.IS_Alive == false) continue;
			//move
			MoveDir = &(S.Mover[S.dir]);
			direction nowdir = S.dir;
			int Smellx = -1, Smelly = -1;
			bool ISMove = false;
			for (int i = 0; i < MoveDir->size(); ++i) {

				x = S.PosX + SharkBasic_Mover[(int)((*MoveDir)[i])][0];
				y = S.PosY + SharkBasic_Mover[(int)((*MoveDir)[i])][1];
				if (x < 0 || N <= x || y < 0 || N <= y)continue;
				if (World[x][y].first == -1) {
					S.dir = (*MoveDir)[i];
					S.PosX = x;
					S.PosY = y;
					ISMove = true;
					break;
				}
				else {
					// 현재 -   기록 시간       유지시간
					if (((time - World[x][y].second) > K)) { //  (3time - 1) 2냄새 지남 
						//빈칸취급
						S.dir = (*MoveDir)[i];
						S.PosX = x;
						S.PosY = y;
						ISMove = true;
						break;
					}//                                              선턴
					else if (World[x][y].first == S.Sharknumber && Smellx == -1) {
						Smellx = x;
						Smelly = y;
						nowdir = (*MoveDir)[i];
					}
				}
			}
			//냄새칸 첫위치
			if (ISMove == false) {
				S.PosX = Smellx;
				S.PosY = Smelly;
				S.dir = nowdir;
			}
		}


		for (int i = 0 ; i < Sharks.size();++i)
		{
			Shark& S = Sharks[i];
			if (S.IS_Alive == false) continue;

			if (World[S.PosX][S.PosY].second == time) {
				S.IS_Alive = false;
				M--;
			}
			else
			{
				World[S.PosX][S.PosY] = make_pair(S.Sharknumber, time);
			}
		}

		if (time > 1000) { time = -1; break; }
	}
	cout << time;
}

int main() {


	std::ios::sync_with_stdio(false);
	std::cin.tie(0);
	std::cout.tie(0);

	AdultShark();
}

Visual Studio 의 LNK1136 에러

개발서 작성 — Tue, 17 Dec 2024 19:35:01 +0900

알고리즘 문제 코드 수정후 재빌드 상태에서 강제 취소 했을때

LNK1136 에러가 났다

해당 에러는 빌드시 불러오는 헤더에서 문제가 생긴것으로 추측하고있다.

디버그 돌려도 해결되지않는다.

다시 빌드 시 문제가 해결된다.

그냥 내가 자주 쓰던 visual studio 단축키

개발서 작성 — Wed, 20 Nov 2024 22:55:57 +0900

ctrl +, 또는 ctrl + t 전체 페이지중 이동

ctrl +. :빠른작업 리팩토링

ctrl +j : 자동완성 표시

ctrl + r +r : 함수나 변수 명을 한번에 변경

ctrl + k +d : 줄 자동 정렬

ctrl + k +c : 주석 으로 변경

ctrl + k + u : 주석 해제 - 하나씩 해제

ctrl + m + o : 정의 부분만 보이기

f12 : 정의 탐색

shift +f12 : 모든 참조 찾기

디버그 중 중단점이후

f11 : 한단계씩 코드 실행 - 함수내부까지 들어감

f10 : 프로시저 단위 실행