Yang.공부방

뿔레전쟁 조합법

yangjae — Sat, 28 May 2022 04:42:53 +0900

기본 조합 템
BwF 초보패키지	컨닝후드 + 놀의동전 + 코볼트의 나무망치
해저갑옷	거북이 등껍질 + 산호스케일
해저왕의 갑옷	BwF초보패키지 + 해저갑옷	초반 딜러가 사용하고 블러디엘프 주면 효율 굿
키메라의 발톱	좀비의 두개골 + 불개미의 발톱
포이즌 클로	좀비의 두개골 + 드레이니의 발톱
샤프 소드	도적의 스코프 + 호러의 이빨
오러블레이드	샤프소드 + 키메라의 발톱	근접딜러 초반 혜자템, 프라우드무어 각성재료
베놈 본	샤프소드 + 포이즌 클로	초반 딜러 혜자템
라이트닝 스태프	침묵의 지팡이 + 엔세서트럴 스태프
얼어붙은 문키	얼음파편 + 문키
카오스 스태프	라이트닝 스태프 + 얼어붙은 문키
진 레드만다라	살라만다심장 + 레드만다라	효율템
자이언트 보우	새끼멀럭 + 골든 링	초반 딜러 혜자템 및 전설템 조합재료
이벤트
녹슨채광용 곡괭이	20라운드 이후 녹슨채광용곡괭이로 7시방향 드레이니 지역 돌 파괴 = 메서슈미트의 양손도끼 획득(100초마다 7000골드 획득)	영웅의 도끼 : 그람 조합재료 (블러드엘프 사망시, 영웅의 도끼 생성불가)
멀럭 킹의 심장	멀럭이 장착 시 귀속
워트의 완벽한 다리	워트의 다리 + 워트의 다른쪽다리(나무뽑기)	중후반 탱커 블링크용
워트의 종	워트의 완벽한 다리 + 워트의 의족	그리스월드레이드(사용)
황금의 검	금궤 + 골든메달	중후반 탱커 블링크용
황금을 집어삼킨 미믹의 금궤	황금의 검 + 미믹의 금궤	신급 레이드 아이템 11시방향 폭포앞 황금광산 이동 시 메갈로돈 레이든 이벤트 발생 잡을 시 성검:엑스칼리버 획득
영웅의 도끼	메서슈미트의 양손도끼 + 영웅의 표식	블러드 엘프 조합 블러드 엘프 사망시 제작불가능
보스아이템
극도로 흥분한 구울의 발톱	구울의 발톱 (8라운드) + 그림자망토	초반 딜러용, 중후반 블러드엘프에게 넘겨주면 좋음
드래곤하트	두번째 심장 (16라운드) + 블랙 스파이더 하트	딜러 중반까지 혜자템
어둠의 표식	악마의 표식 (24라운드) + 쉐이드 가면	헬 난이도 이상 10라운드마다 나오는 아랫라인용
쿠카이의 혼이 깃든 목걸이	복수의 결정 (32라운드) + 쿠카이의 혼 조각	딜러 펫 용
얼어붙은 모래시계	시간의 속박 (40라운드) + 사피론의 구슬	최종 보스 CC용, 펫 용
응축된 영혼의 결정	타이머 클리어, 시민 5명 몰살 후 저주받은 악령 제거 시 억울한 영혼의 집결체 + A급 영혼주머니	블링크 용
룬 아이템
라그나로스 - 설퍼라스		라이너 장착용, 히든엔딩 조합용
티란데 - 달의 힘		민첩 영웅용
네쥴 - 서리한		호러작, 헬 난이도 이상 추가 웨이브 막기용
리프 - 리프의 우정반지		빈곤한 지능캐 템
발록 - 소울이터		히든엔딩 조합용
뿔레 - 뿔레의 손		히든엔딩 조합용
크사르팍스 - 크사르팍스의 인장		데스윙 레이드 조합용
히든엔딩 입장권	뿔레의 손 + 설퍼라스 + 소울이터
데스윙 레이드 입장권	파멸의 뿔피리 + 크사르팍스의 인장 + 이계의 보석
이스터에그 아이템
진정한 서리한	네쥴 착용 시 귀속
멀럭킹의 심장	멀럭 착용 시 귀속
리프의 완성된 우정 반지	레이나 착용 시 귀속
문 크리스탈 팬던트	1. 엘리멘탈 쥬얼리를 제이나에게 장착 = 귀속템을 제외한 아이템을 반출 2. 엘리멘탈 쥬얼리를 시민에게 넣어준다 = 문크리스탈 팬던트 획득
전설아이템
레오닉의 왕관	불멸자의 로브 + 칼리온의 투구	둠 크라운(신급) 조합재료
파괴의 뿔	제르올의 투구 + 스톰윈드의 라이온 뿔피리
이지스	마법 무효 목걸이 + 아쥰의 정수
라이젠의 유물	노페인노게인(공),노페인노게인(체),노페인노게인(방)
아카식 레코드의 일면	뿔레의 검 + 뿔레의 방패 + 뿔레의 축복
피닉스 파이어의 불꽃	파이어의 불꽃 + 피닉스 건틀릿
인피니티	크사르팍스소울 + 어둠의 구슬 + 타락의 오브
황금기사 쿠란의 세트	쿠란의 갑옷 + 쿠란의 장갑 + 쿠란의 신발
제우스의 힘	제우스의 번개 + 썬더 샤먼의 클러
하드스킨 건틀릿	파이어핸드 건틀릿 + 오우거파워 건틀릿
세레비의 완벽한 뿔	세레비의 약한 뿔 + 세레비의 선한 뿔
이지스	아준의 정수 + 마법 무효 목걸이
레오닉의 왕관	칼리온의 투구 + 불멸자의 로브
강화된 문 아머	문 아머 + 자유의 상징	쓰레기 템
서펀트 클라우드	서펀트 워드 + 클라우드의 뿔
소울 위드	소울 젬 + 쉬머 위드
에이션트 그린	에이션트 피겨린 + 포레스트 에메랄드 반지 + 질풍의 신발
헤르메스의 신발	드레이니의 깃발 + 와이번의 날개
엘릭서	버쳐의 썩은 고기 + 회복의 서
레드 드래곤의 심장	레드 드래곤 에그 + 그래닛골렘의 심장 + 라바 스톤
카두케우스	진 침묵의 지팡이 + 일루션 스태프
죽음의 서	죽음의 책 + 죽음의 낙인
올인원	뿔레의 납골단지 + 바람빛 슬픔
제사장의 지팡이	마나의 지팡이:로임 + 고스트 블러드 키
블링크 스태프	빅풋 치프틴 부츠 + 젤다의 이상한 힘
천공의 지팡이:샤르	칼라드볼그 + 롱기누스의 창
신궁 : 엘티노	페일노트 + 고대의 장고
빛의 방패 : 가이아스	명예의 방패 + 마소그의 방패
정령왕의 가호	다크트렌트의 가지 + 정령의 날개
프로스트 하트	반 이상 소화되지 않은 펭귄 + 하프 플레이트
포이즌 스피어	칸의 장갑 + 쉐도우 본 토템
피의 검 : 샨그리	샤티로스의 클로우 + 데스 마스크
피의 목걸이	타이콘다리우스의 피 + 스파이더 링
키틴 블레이드	보팔 블레이드 + 메테오릭 스워드
바람의 지배자	쿠엘탈라스 부츠 + 바람의 창
윈드 포스	자이언트보우 + 레바테인 + 뿔레의 가면
진정한 토르의 망치	놀 오버시어의 망치 + 토르의 망치
죽음의 낫 : 데스사이드	사신의 낫 + 치프틴엑스
가에보르그	스냅드래곤의 발톱 + 화이트베어 건틀릿
언브로큰엑스	테러의 망치 + 테러의 어깨보호구
루 라바다	루스골드 + 루스실버
폭풍을 부르는 마검 : 스톰브링거	마검 : 미스텔테인 + 전설의 검
텔레포트 소드	텔레포테이션 스태프 + 켈렌의 탈출의 검
브릴란테	링 오브 플레임 + 시어링 블레이드 + 진 불꽃의 반지
신급 아이템
로드 오브 아클레피오스	숭고한 카즈의 지팡이 + 제사장의 지팡이 + 카오스 스태프	수상한 상인 NPC 카즈의 지팡이, 변환 시 숭고한 카즈의 지팡이(30번 사용) 라이트닝 스태프 + 얼어붙은 문키 = 카오스 스태프
멸망의 지팡이 : 바나르간드	죽음의 낫:데스사이드 + 가에보르그 + 진정한 토르의 망치
태초의 검 : 스퀴테	성검 : 엑스칼리버 + 폭풍을 부르는 마검 : 스톰브링거 + 루 라 바다
파멸의 검 : 티르빙	가에보르그 + 언브로큰엑스 + 죽음의 낫 : 데스사이드
둠 크라운	레오닉의 왕관 + 서펀트 클라우드 + 소울위드
퀴네에	악령의 저주가 깃든 물건 + 프로스트 하트 + 하드스킨건틀릿	수상한 상인한테 저주받은 물건 구매 후 60번 사용
하데스의 힘	올인원(바람빛 슬픔, 뿔레의 납골 단지) + 응축된 어둠의 힘
드래곤의 심장	레드 드래곤의 심장 + 죽음의 서
쿠란		드랍 확률 1퍼라 불리며 라그나로스,리프,발록 소울을 조합해야 만들 수 있는 쿠란소울을 띄어 제가 직접 쿠란이 되보았습니다. [마침 포지션도 탱커]

타입변환

yangjae — Fri, 10 Apr 2020 21:11:20 +0900

타입변환이란?

: 데이터 타입을 다른 데이터 타입으로 변환 하는 것 ex) byte ↔ int , int ↔ double

자동(묵시적) 타입변환 : Promotion

작은 크기의 타입 → 큰 크기의 타입으로 자동 타입변환(메모리크기)

byte(1) < short(2) < int(4) < long(8) < float(4) < double(8) ※float이 long보다 큰 타입으로 표시한 이유는 표현할 수 있는 값의 범위가 float이 더 크기때문

[묵시적 타입변화의 예시]

강제(명시적) 타입변환 : Casting

큰 크기의 타입 → 작은 크기의 타입단위로 쪼개고 끝 한부분만 작은 타입으로 강제적 변환

[범위를 초과하여 에러 발생]

[변수 앞에 변환할 타입을 명시한다]

[출력값은 쓰레기값 -128이 나온다]

[if문을 통해 검사를 하고 계산하는 방법이다]

[왼쪽 결과값 : -4] [오른쪽 결과값 : 0]

정밀도 손실을 피하기 위해서 float 보다는 double을 사용한다

float : 부호(1비트) + 지수(8비트) + 가수(23비트)

double : 부호(1비트) + 지수(11비트) + 가수(52비트)

연산식에서 자동타입 변환

: 같은 타입의 피연산자(operand)간에만 수행

: 정수 연산일 경우 int타입을 기본으로 한다.

: 서로 다른 타입의 피연산자는 크기가 큰 타입으로 자동변환 후 연산

데이터 타입

yangjae — Wed, 8 Apr 2020 21:16:11 +0900

데이터타입(Data Type)이란?

: 자바 언어가 처리할 수 있는 데이터(자료) 종류를 의미하며 기본 데이터형과 참조 데이터형이 있다.

기본타입 (primitive)

: 메모리에는 0 과 1 을 저장하는 최소 기억단위인 비트(bit)가 있다.

8개의 비트를 묶어 바이트(byte)라고 한다 ex)1byte = 8bit [0000 0000]

값 종류	타입	메모리 사용 크기		저장되는 값의 범위
정수	byte	1 byte	8 bit	-128~127
	short	2 byte	16 bit	-32768~32767
	int	4 byte	32 bit	-2147483648~214838647
	long	8 byte	64 bit	-9223372036854775808~9223372036854775807
실수	float	4 byte	32 bit	1.40239846e-45f ~3.40282347e+38f
실수	double	8 byte	64 bit	4.94065645841246544e-324~1.79769313486231570e+308
문자	char	2 byte	16 bit	'\u0000' ~ 'uFFFF' (16비트 유니코드 문자 데이터)
논리	boolean	1 byte	8 bit	true 또는 false

각 타입별 저장되는 값의 범위보다는 메모리크기를 알아두면 좋다. 메모리 크기를 알고있으면 사용되는 값의 범위를 대략 알 수 있기 때문이다.

정수타입의 저장되는 값의 범위는 -2^(n-1) ~ (2^(n-1)-1)이다.

변수마다 사용할 수 있는 값의 범위를 초과하면 오버플로우(overflow)현상이 발생하는데 이것은 쉽게 설명하면 그릇에 담을 수 있는 한계를 초과하여 흘러넘친다는 뜻이다.

오버플로우 현상이 발생하면 엉뚱한 값이 들어갈 수 있고 에러의 원인이 된다.

[byte타입의 값을 초과하여 최소값부터 다시 반복 저장된 결과이다(쓰레기값)]

[정수타입] (byte, short, int, long)

byte타입 : 색상정보 및 파일 또는 이미지 등 이진데이터를 처리할 때 사용

char타입 : 자바는 모든 문자를 유니코드(Unicode)로 처리한다(직접 유니코드 정수 값(음수값은 없다)을 저장할 수 있다 ex) char c = 65; 또는 char c = '\u0041';)

short타입 : C언어와 호환을 위해 사용하며 비교적 자바에서는 잘 사용되지 않는다

int타입 : 메모리가 크게 부족하지 않다면 정수를 저장할 때 int타입을 사용한다

long타입 : 수치가 큰 데이터를 다루는 프로그램에서 필수적으로 사용한다 ex)은행 및 우주 관련된 프로그램

[실수타입] (float, double) 소수점값을 나타내기 위해 사용 (부동소수점(floating-point)방식으로 저장)

flolat : 부호(1bit) + 지수(8bit) + 가수(23bit) = 32bit = 4byte

double : 부호(1bit) + 지수(11bit) + 가수(52bit) = 64bit = 8byte

[실수 리터럴의 기본타입은 double이므로 float리터럴은 끝에 F,f를 붙이도록 한다]

[정수 리터럴에 10의 지수를 나타내는 E,e가 있을 경우 실수타입에 저장해야 한다]

[논리타입] (boolean) true 또는 false 값을 저장하며 조건문 또는 제어문의 실행 흐름을 변경할 때 사용 (소문자만 인식)

[stop변수의 값이 false 이므로 else의 값이 출력된다]

참조타입 (reference)

: 객체의 번지를 참조하는 타입으로 배열(array), 열거(enum), 클래스(class), 인터페이스(interface) 타입을 말한다.

기본과 참조의 차이는 저장되는 값이 무엇인가? 이다

기본타입은 선언된 변수는 실제 값을 변수에 저장하지만 참조타입은 배열, 열거 ,클래스, 인터페이스를 이용하여 메모리에 번지를 값으로 갖게된다.

[자료 참고 : https://kingpodo.tistory.com/54]

메모리 사용 영역

java.exe로 프로그램을 실행하면 JVM이 실행된다. JVM은 운영체제에서 할당받은 메모리 영역을 메소드,스레드,힙과 같은 세부 영역으로 구분해서 사용한다.

이때 쓰레드 영역마다 하나의 JVM스택영역이 존재하게 된다.

[자료 참고 : https://kingpodo.tistory.com/54]

1. 메소드 영역 (Method Area)

: 런타임 상수 풀, 필드 / 메소드 데이터, 메소드 코드, 생성자 코드 등으로 분류하여 저장한다.

: 메소드 영역은 JVM이 시작할 때 생성되고 모든 스레드가 공유하는 영역

2. 힙 영역 (Heap Area)

: 객체와 배열이 생성되는 영역이며 JVM스택영역의 변수나 다른 객체의 필드에서 참조한다.

: 참조하는 변수나 필드가 없다면 의미없는 객체가 되기 때문에 쓰레기로 취급하고 JVM은 Garbage Collector를 실행시켜 쓰레기 객체를 힙 영역에서 자동으로 제거합니다.

: Java는 개발자가 직접적으로 객체를 제거시키는 방법을 제공하지 않는다(System.gc() 메소드가 있지만 JVM에게 요청을 하는 형태이다)

3. JVM(Java Virtual Machicne) Stack Area

: 각 스레드마다 하나씩 존재하며 스레드가 시작될 때 할당된다.

: 추가적으로 스레드를 생성하지 않으면 main스레드만 존재하므로 JVM스택도 하나이다.

: JVM스택은 메소드를 호출할 때 마다 프레임을 추가하고 메소드가 종료되면 프레임을 제거한다.

: 배열은 객체로 취급한다 (내부에서 생성된 변수는 해당 로컬 변수 스택에만 존재하여 해당 구문을 나오면 제거되어 외부에서 사용이 불가하지만 배열은 스택 영역에 생성되지만 배열 데이터 자체는 Heap영역에 생성되어 제거되지않는다)

변수와 리터럴

yangjae — Tue, 7 Apr 2020 21:06:21 +0900

변수란? 하나의 값을 저장할 수 있는 메모리공간(변할 수 있는 수)

: 변수는 선언된 블록 내에서만 사용이 가능하다 (아래 사진은 블럭안에 있는 변수를 밖에서 사용하려 시도하다 오류가 발생한 사진이다)

변수 선언방법 (타입 + 변수이름)

1
2
int age;
double value;

변수 선언과 값 저장(우측에 있는 값을 좌측 변수에 저장)

1
2
int age = 1;        
double value = 1.5;

변수 이름을 위한 명명 규칙 

  작성 규칙

 예 

 첫번째 글자는 문자이거나 '$','_'이어야 하며 숫자는 사용불가

 가능 : price, $price, _companyName
불가능 : 1v, @speed, $#value

 영어 대소문자 구분이 된다

 firstname 과 firstName 은 다른 변수

  첫문자는 소문자로 시작하되, 다른 단어가 붙을경우 대문자로 한다

 amxSpeed,firstName, carBodyColor 

 문자 수 제한이 없다

  자바 예약어는 사용불가

 기본 데이터 값, 접근지정자, 클래스 관련 등등...

변수값 읽기

변수는 초기화가 되어야 읽을 수 있으며, 초기화되지 않는 변수는 읽을 수 없다

1
2
int value;
int result = value +10;

[변수를 초기화 하지 않을 시 오류 발생]



1
2
int value = 30;
int result = value +10;
cs
[변수를 사용하지 않을 시 뜨는 문구] 
  리터럴이란? 소스 코드 내 직접 입력된 값

정수 리터럴 (byte, char, short, int, long)

1
2
3
4
5
6
7
8
9
10
11
//소수점이 없는 정수 리터럴은 10진수
int var1 = 10;
System.out.println("var1 : "+var1);//출력결과 : 10
    
//0으로 시작되는 리터럴은 8진수
int var2 = 010;
System.out.println("var2 : "+var2);//출력결과 : 8
    
int var3 = 0x10;
//0x 또는 0X로 시작하고 0~9 숫자나 알파벳으로 구성된 리터럴은 16진수
System.out.println("var3 : "+var3);//출력결과 : 16
cs

실수 리터럴 (float, double)

1
2
3
4
5
6
7
//소수점이 있는 리터럴은 10진수 실수로 간주
double var4 = 0.25;
System.out.println("var4 : "+var4); //출력결과 : 0.25
 
//대문자 E 또는 소문자 e가 있는 리터럴은 10진수 지수와 가수로 간주한다.
double var5 = 2E5;
System.out.println("var5 : "+var5); //출력결과 : 200000.0
cs

문자 리터럴 (char)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
//작은 따옴표(')로 묶은 텍스트는 하나의 문자 리터럴로 간주한다.ex) 'A', '한', '\t', '\n'
//\가 들어가면 이스케이프문자라고 하는데 특수한 용도로 사용
char var6 = 'A';
System.out.println("var6 : "+var6);
        
char var7 = '한';
System.out.println("var7 : "+var7);
        
System.out.println('\t' + "들여쓰기");//들여쓰기
System.out.println("\t들여쓰기2");
        
System.out.println('\n' + "줄바꿈");//줄바꿈
System.out.println("\n줄바꿈2");
        
System.out.println('\r' + "리턴");//r은 리턴의 개념
System.out.println("\r리턴2");
        
System.out.println("This" + '\'' + "s Java");//작은 따음표('\'')
System.out.println("이것은" + '\"' + "자바" + '\"' + "입니다");//큰 따음표('\"')
        
char var8 = '\u0041';
System.out.println("var8 : " + var8);
Colored by Color Scripter
cs

[출력 결과]

문자열 리터럴 (String)

1
2
3
4
5
//문자열 리터럴 (문자열 리터럴을 저장 할 수 있는 타입은 string밖에 없다)
//큰 따옴표("")로 묶은 텍스트는 문자열 리터럴로 간주한다. ex) "대한민국"
//문자열 리터럴 내부에서 이스케이프 문자 사용가능 ex) "탭 만큼 이동 \t 합니다"
String var9 = "Yang";
System.out.println("작성자는\t" + var9 + "입니다");
cs

[출력 결과]

논리 리터럴 (boolean)

1
2
3
//논리 리터럴(논리 리터럴은 boolean밖에 없다)
boolean var10 = true;
System.out.println("var10 : " + var10);
cs

[출력 결과]

주석처리 컴파일(인코딩)오류

yangjae — Sat, 4 Apr 2020 22:33:25 +0900

주석처리 컴파일 중 인코딩 오류 발생

컴파일 오류

컴파일 시 error: unmappable character (0xEC) for encoding x-windows-949오류 발생

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
C:\Temp>javac Hello.java
 
Hello.java:5: error: unmappable character (0xEC) for encoding x-windows-949
        //?옉?꽦?옄 : Yang
          ^
Hello.java:5: error: unmappable character (0xEC) for encoding x-windows-949
        //?옉?꽦?옄 : Yang
            ^
Hello.java:5: error: unmappable character (0xEC) for encoding x-windows-949
        //?옉?꽦?옄 : Yang
              ^
Hello.java:7: error: unmappable character (0xEC) for encoding x-windows-949
        ?옉?꽦?씪 : 2020.4.4
        ^
Hello.java:7: error: unmappable character (0xEC) for encoding x-windows-949
        ?옉?꽦?씪 : 2020.4.4
          ^
Hello.java:7: error: unmappable character (0xEC) for encoding x-windows-949
        ?옉?꽦?씪 : 2020.4.4
            ^
Hello.java:8: error: unmappable character (0xED) for encoding x-windows-949
        ?뀒?뒪?듃?슜
        ^
Hello.java:8: error: unmappable character (0xEC) for encoding x-windows-949
        ?뀒?뒪?듃?슜
          ^
Hello.java:8: error: unmappable character (0xED) for encoding x-windows-949
        ?뀒?뒪?듃?슜
            ^
Hello.java:8: error: unmappable character (0xEC) for encoding x-windows-949
        ?뀒?뒪?듃?슜
              ^
10 errors
Colored by Color Scripter
cs

[오류 내용]

교재의 예문을 따라 하는 과정 중 오류가 발생하여 내용을 살펴보니 인코딩에 문제가 있다는 것을 알게 되었다.

한글 문자는 역사적인 이유로 각각의 문자를 비트열로 부호화하는 방식(인코딩)이 몇가지 있는데 대표적으로 utf-8, euc-kr, cp949, ms949이 있다.

위 오류는 utf-8로 인코딩된 코드를 자바 컴파일에서 한글 윈도우의 기본 인코딩을 따라서 ms949 방식으로 읽으려고 시도 했지만 실패하여 발생한 것이다.

utf-8, ms949와 같은 한글 인코딩은 1바이트로 표시되는 영문자를 포함한 ascii문자에서만 서로 호환성을 가질 뿐이라서 영문자들은 잘 표시하지만 한글은 알 수 없다는 문자로 해석될 뿐이다.

해결방법

해결방법으로는 컴파일러의 인코딩 방식과 소스파일을 일치시켜주는 3가지 방법이 있는데 아래와 같다.

편집기에서 파일 인코딩을 ms949로 저장 하도록 하는 방법
통합개발환경에서 컴파일 옵션으로 -encoding utf-8을 설정하는 방법
자바 컴파일러에게 명시적으로 파일의 인코딩을 지정하는 방법 ex)javac 파일명 -encoding utf-8

1
C:\Temp>javac Hello.java -encoding UTF-8
cs

자바(JDK), 이클립스 설치 및 환경구축

yangjae — Fri, 3 Apr 2020 21:33:40 +0900

Java SE 구현체 종류

1. JDK - 자바 프로그램 개발 및 실행하기 위해 반드시 설치(JRE+개발도구)

2. JRE - 자바 프로그램을 실행할 경우 설치(JVM+표준 클래스 라이브러리)

자바 개발 도구 (JDK) 설치 설치 파일 다운로드 사이트 : (http://www.oracle.com/) ※운영체제별, CPU종류별 파일이 다름

이클립스 (Eclipse) 설치 설치 파일 다운로드 사이트 : (https://www.eclipse.org/) ※사용 시 JDK필요

환경 변수 생성 및 수정

: "JAVA_HOME" 생성 - JDK 설치 디렉토리로 지정(서버구동시 JDK의 설치 위치를 알기 위해 사용)

: "PATH" 수정 - %JAVA_HOME%\bin; 추가(임의의 디렉토리에서 자바 명령어(javac.exe, java.exe)를 실행시키기 위해 설정)

이클립스 설치

메모장으로 컴파일

이클립스에서 Hello World 찍기

자바 시작하기

yangjae — Fri, 3 Apr 2020 21:33:31 +0900

자바란?

1995년도 썬마이크로시스템즈(썬)에서 최초 발표한 언어이다.(가전 제품에서 사용할 목적인 오우크(Oak)언어에서 시작하여 인터넷 프로그래밍 언어로 발전하면서 자바라는 이름으로 변경

2010년 오라클에서 썬을 인수하여 개발,관리,배포를 주관한다

특징

1. 이식성이 높다.

: 소스코드파일(.java) ->한 번의 컴파일-> 클래스파일(.class)->Ms윈도우,리눅스,맥

2. 객체지향 언어.

: 부품 객체를 먼저 만들고, 이것들을 조합해서 전체 프로그램을 완성하는 기법

: 자바는 처음부터 OOP(Object Oriented Programming) 개발용 언어로 설계되었다. (캡슐화,상속,다형성 기능 지원)

3. 함수적 스타일 코딩 지원(람다식(Lambda Expressions))

: 코드를 간결하게 작성가능

: 컬렉션 요소를 필터링, 매핑, 그룹핑, 집계처리 시 사용

4. 메모리 자동 관리.

: 사용하지 않는 객체를 자동으로 메모리에서 제거한다.

: 핵심 기능 코드에 집중할 수 있도록 해준다.

5. 다양한 애플리케이션 개발가능.

: 콘솔 프로그램, UI애플리케이션, 서버 애플리케이션, 모바일 앱 등을 개발가능

: Java SE - 기본에디션(자바프로그램을 실행시키는 JVM정의, 자바 프로그램들이 공통으로 사용하는 개발도구와 API, 구현체 - JDK)

: Java EE - 서버 애플리케이션 개발 에디션(웹 애플리케이션, 웹 서비스, 분산 컴포넌트를 위한 개발 도구와 API, 구현체 - WAS(Web Application server(Tomcat, WebLogic, Jeus, Jboss...)))

: Java ME - 임베디드 또는 모바일 장비를 위한 개발도구

6. 멀티 스레드(Multi-Thread)를 쉽게 구현가능

: 동시에 여러 작업을 할 경우 - 병렬처리 필요 - 멀티 스레드 필요

: 대용량 작업을 빨리 처리할 경우 - 병렬처리 필요 - 멀티 스레드 필요

: 운영체제 별 멀티스레드를 이용하는 API가 다름 - Java API로 일관된 생성 및 관리

7. 동적로딩(Dynamic Loading)을 지원

: 필요한 시점에 동적을 로딩해서 객체를 생성할 수 있다.

: 유지보수시 특정 객체만 쉽게 수정 및 교체 가능

8. 오픈소스 라이브러리가 풍부

: 노력과 시간 비용절약 및 유지보수의 편리성

[SVN] 폴더 제외

yangjae — Wed, 10 Jul 2019 09:47:45 +0900

*.o *.lo *.la *.al .libs *.so *.so.[0-9]* *.a *.pyc *.pyo __pycache__ *.rej *~ #*# .#* .*.swp .DS_Store [Tt]humbs.db obj Temp *.suo *.user *.pidb *.userprefs *.csproj *.pidb *.sln *.csproj *.unityproj Library Temp

[프로토타입]0626타일클릭 후 몬스터그룹 이동시키기,건물파괴

yangjae — Wed, 26 Jun 2019 03:20:13 +0900

프로토타입진행중.unitypackage

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

[프로토타입] 몬스터그룹이 본진 공격하기

yangjae — Thu, 20 Jun 2019 00:25:57 +0900

몬스터그룹 이동시키기.unitypackage

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
 
public class TestCharacter : MonoBehaviour
{
    public float g;
    public float h;
    public float f;
 
    public float speed;
    
    public Vector2 vec2;
 
    public List<GameObject> openList;
    public List<GameObject> closeList;
 
    private void Start()
    {
        this.speed = Random.Range(1.0f, 2.0f);
    }
 
    public TestCharacter(Vector2 vec2)
    {
        this.vec2 = vec2;
    }
}
 
Colored by Color Scripter
cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
using UnityEngine.UI;
 
public class TestMonster : MonoBehaviour
{
    public int colCount, rowCount;
    public int fenceX, fenceY;
 
    public Vector2[] blockPos;
    public Vector2[] fencesPos;
    public Vector2[] characterPos;
 
    //private Vector2[] monsterSpanPos;
    private List<Vector2> monsterSpanPos = new List<Vector2>();
 
    public Button moveMonsterBtn;
    public Button CreateMonsterLeftSpanBtn;
    public Button CreateMonsterRightSpanBtn;
    public Button CreateMonsterBottomSpanBtn;
    public Button testBtn;
 
    public GameObject testBuildingBtn;
 
    public Text txtTimer;
    private float timer = 5f;
 
    private int col = 0, row = 0;
    private int tileWidth = 64;
    private int tileHeight = 32;
    
    private GameObject monster;
    private GameObject workman;
 
    private GameObject village;
    private GameObject fence;
 
    private GameObject mapTile;
    private Coroutine routine;
    private Vector2 buildingPos;
 
    private Dictionary<Vector2, GameObject> dicTiles = new Dictionary<Vector2, GameObject>();
 
    public List<GameObject> characterList = new List<GameObject>();
    public List<GameObject> monsterList = new List<GameObject>();
 
    private GameObject motherNode;
    private GameObject villageNode;
    private GameObject selectedTile;
 
    private int testCnt1 = 0;
    private int testCnt2 = 0;
    
    private void Start()
    {
        this.CreateCharacter();
        this.CreateMap();
 
        this.ButtonManager();
 
        StartCoroutine(TouchMonsterSpanPos());
    }
 
    private IEnumerator TouchMonsterSpanPos()
    {
        while(true)
        {
            var ray = Camera.main.ScreenToWorldPoint(Input.mousePosition);
            RaycastHit2D hit = Physics2D.Raycast(ray, Vector2.zero);
 
            if (Input.GetMouseButtonDown(0))
            {
                if (hit.collider != null)
                {
                    this.monsterSpanPos.Add(hit.collider.GetComponent<TestTile>().vec2);
                }
            }
            yield return null;
        }
    }
 
    #region 버튼매니저
    private void ButtonManager()
    {
        this.moveMonsterBtn.onClick.AddListener(() =>
        {
            this.TestFindNodes();
        });
 
        this.testBtn.onClick.AddListener(() =>
        {
 
            //StartCoroutine(this.MonsterAttack());
        });
 
        #region 캐릭터생성버튼
        this.CreateMonsterLeftSpanBtn.onClick.AddListener(() =>
        {
            this.CreateLeftMonster();
        });
 
        this.CreateMonsterRightSpanBtn.onClick.AddListener(() =>
        {
            this.CreateRightMonster();
        });
 
        this.CreateMonsterBottomSpanBtn.onClick.AddListener(() =>
        {
            this.CreateBottomMonster();
        });
        #endregion
    }
    #endregion
 
    private void TestFindNodes()
    {
        foreach (var monster in this.monsterList)
        {
            var tile = this.dicTiles[monster.GetComponent<TestCharacter>().vec2];
 
            this.motherNode = tile;
 
            monster.GetComponent<TestCharacter>().openList = new List<GameObject>();
            monster.GetComponent<TestCharacter>().closeList = new List<GameObject>();
 
            if (this.FindeTargetNode(monster) == true)
            {
                StartCoroutine(this.FindNextPosImpl(monster));
            }
        }
    }
 
    private bool FindeTargetNode(GameObject monster)
    {
        if (villageNode != null)
        {
            while (true)
            {
                if (villageNode != motherNode)
                {
                    this.FindNode(monster);
                }
                else
                {
                    Debug.Log("길찾기 완료");
                    return true;
                }
            }
        }
        else
        {
            Debug.Log("어디로 가");
            return false;
        }
    }
 
    //길찾기
    #region 길찾기
 
    private void FindNode(GameObject monster)
    {
        var monsterScript = monster.GetComponent<TestCharacter>();
        var mother = motherNode.GetComponent<TestTile>().vec2;
 
        var motherX = mother.x - 1;
        var motherY = mother.y - 1;
        var maxX = mother.x + 1;
        var maxY = mother.y + 1;
 
        if (motherX < 0)
        {
            motherX = 0;
        }
        if (motherY < 0)
        {
            motherY = 0;
        }
 
        for (int x = (int)motherX; x <= maxX; x++)
        {
            for (int y = (int)motherY; y <= maxY; y++)
            {
                if (x < this.colCount && y < this.rowCount)
                {
                    var data = new Vector2(x, y);
 
                    var tile = this.dicTiles[data];
 
                    if (tile.GetComponent<TestTile>().isBlock != true && !monsterScript.closeList.Contains(tile))
                    {
                        if (data.x == motherX && data.y == mother.y || data.y == mother.y)
                        {
                            monsterScript.openList.Add(tile);
                            this.SetFGH(tile, motherNode);
                        }
                        if (data.y == motherY && data.x == mother.x || data.x == mother.x)
                        {
                            monsterScript.openList.Add(tile);
                            this.SetFGH(tile, motherNode);
                        }
 
                        monsterScript.openList.Remove(motherNode);
                        monsterScript.closeList.Add(motherNode);
                    }
                }
            }
        }
 
        if (motherNode.GetComponent<TestTile>().isFence)
        {
            motherNode.GetComponent<TestTile>().capacity--;
 
            if (motherNode.GetComponent<TestTile>().capacity <= 0)
            {
                motherNode.GetComponent<TestTile>().isBlock = true;
            }
            //TODO
        }
 
        IEnumerable<GameObject> sortNode = monsterScript.openList.OrderBy(x => x.GetComponent<TestTile>().f);
 
        this.selectedTile = sortNode.FirstOrDefault<GameObject>();
        this.motherNode = this.selectedTile;
 
        monsterScript.closeList.Add(motherNode);
    }
    #endregion
 
    #region 이동하기
    private IEnumerator FindNextPosImpl(GameObject testMonster)
    {
        var monster = testMonster.GetComponent<TestCharacter>();
 
        for (int i = 0; i < monster.closeList.Count; i++)
        {
            testMonster.GetComponent<Animator>().Play("run");
 
            while (true)
            {
                var dir = (monster.closeList[i].transform.position - testMonster.transform.position).normalized;
 
                var nextNode = Vector2.Distance(testMonster.transform.position, monster.closeList[i].transform.position);
 
                testMonster.transform.position += dir * monster.speed * Time.deltaTime;
 
                if (nextNode <= 0.03f)
                {
                    break;
                }
 
                yield return null;
            }
 
            if (i + 1 < monster.closeList.Count)
            {
                if (monster.closeList[i + 1].GetComponent<TestTile>().isFence == true || monster.closeList[i + 1].GetComponent<TestTile>().isBuilding == true)
                {
                    monster.closeList[i + 1].GetComponent<TestTile>().capacity--;
 
                    testMonster.GetComponent<Animator>().Play("attack");
 
                    //TODO
 
                    break;
                }
            }
 
            var distance = Vector2.Distance(testMonster.transform.position, this.villageNode.transform.position);
 
            if (distance <= 0.04f)
            {
                testMonster.GetComponent<TestCharacter>().vec2 = this.villageNode.GetComponent<TestTile>().vec2;
 
                testMonster.GetComponent<Animator>().Play("idle");
 
                Debug.Log("도착");
                break;
            }
        }
 
        yield return new WaitForSeconds(0.6f);
 
        testMonster.GetComponent<Animator>().Play("idle");
 
        //TODO
    }
    #endregion
 
    #region 타일초기화
    private void ClearMap()
    {
        for (int i = 0; i < colCount; i++)
        {
            for (int j = 0; j < rowCount; j++)
            {
                var tiles = new Vector2(j, i);
 
                var tile = dicTiles[tiles];
 
                if (!tile.GetComponent<TestTile>().isBlock || tile.GetComponent<TestTile>().isFence)
                {
                    tile.GetComponent<SpriteRenderer>().color = Color.white;
                }
            }
        }
    }
    #endregion
 
    #region FGH 입력하기
    private void SetFGH(GameObject tile, GameObject character)
    {
        var tileScript = tile.GetComponent<TestTile>();
 
        var getG = tile.GetComponent<TestTile>().g;
        var getH = tile.GetComponent<TestTile>().h;
        getG = Mathf.Round(Vector2.Distance(tile.GetComponent<TestTile>().vec2, character.GetComponent<TestTile>().vec2) * 10);
        var dx = Mathf.Abs(tile.GetComponent<TestTile>().vec2.x - this.village.GetComponent<TestTile>().vec2.x);
        var dy = Mathf.Abs(tile.GetComponent<TestTile>().vec2.y - this.village.GetComponent<TestTile>().vec2.y);
 
        getH = (dx + dy) * 10;
 
        tile.GetComponent<TestTile>().f = getG + getH;
 
        tileScript.G.text = getG.ToString();
        tileScript.H.text = getH.ToString();
        tileScript.F.text = tile.GetComponent<TestTile>().f.ToString();
    }
    #endregion
 
    #region 몬스터 생성
    private void CreateLeftMonster()
    {
        for (int i = 0; i < 5; i++)
        {
            this.monster = Instantiate(Resources.Load<GameObject>("Prefabs/monster"));
 
            var data = new Vector2(this.monsterSpanPos[2].x, this.monsterSpanPos[2].y);
 
            var leftMonsterPos = this.dicTiles[data];
 
            this.monster.AddComponent<TestCharacter>();
            this.monster.GetComponent<TestCharacter>().vec2 = leftMonsterPos.GetComponent<TestTile>().vec2;
 
            monster.transform.position = leftMonsterPos.transform.position;
 
            this.monsterList.Add(monster);
        }
    }
    private void CreateRightMonster()
    {
        for (int i = 0; i < 5; i++)
        {
            this.monster = Instantiate(Resources.Load<GameObject>("Prefabs/monster"));
 
            var data = new Vector2(this.monsterSpanPos[1].x, this.monsterSpanPos[1].y);
 
            var rightMonsterPos = this.dicTiles[data];
 
            this.monster.AddComponent<TestCharacter>();
            this.monster.GetComponent<TestCharacter>().vec2 = rightMonsterPos.GetComponent<TestTile>().vec2;
 
            monster.transform.position = rightMonsterPos.transform.position;
 
            this.monsterList.Add(monster);
        }
    }
    private void CreateBottomMonster()
    {
        for (int i = 0; i < 5; i++)
        {
            this.monster = Instantiate(Resources.Load<GameObject>("Prefabs/monster"));
 
            var data = new Vector2(this.monsterSpanPos[0].x, this.monsterSpanPos[0].y);
 
            var BottomMonsterPos = this.dicTiles[data];
 
            this.monster.AddComponent<TestCharacter>();
            this.monster.GetComponent<TestCharacter>().vec2 = BottomMonsterPos.GetComponent<TestTile>().vec2;
 
            monster.transform.position = BottomMonsterPos.transform.position;
 
            this.monsterList.Add(monster);
        }
    }
    #endregion
 
    #region 맵, 타일, 캐릭터 생성
    //캐릭터 생성입력
    private void CreateCharacter()
    {
        foreach (var characterPos in this.characterPos)
        {
            this.workman = Instantiate(Resources.Load<GameObject>("Prefabs/hero"));
 
            this.CreatedCharacter(this.workman, characterPos.x, characterPos.y);
        }
    }
 
    //캐릭터생성
    private void CreatedCharacter(GameObject character, float x, float y)
    {
        var vec2 = new Vector2(x, y);
 
        character.AddComponent<TestCharacter>();
        character.GetComponent<TestCharacter>().vec2 = vec2;
 
        this.characterList.Add(character);
 
        var screen = this.MapToScreen(vec2);
 
        var screenPos = Camera.main.ScreenToWorldPoint(new Vector2(screen.x, screen.y));
 
        character.transform.position = new Vector3(screenPos.x, screenPos.y, 0);
    }
 
    //맵생성입력
    private void CreateMap()
    {
        this.village = Instantiate(Resources.Load<GameObject>("Prefabs/128x128building"));
        this.buildingPos = new Vector2(this.colCount / 2, this.rowCount / 2);
        this.CreatedMap(village, this.buildingPos.x, this.buildingPos.y);
 
 
        for (int i = 0; i < this.fencesPos.Length; i++)
        {
            this.fence = Instantiate(Resources.Load<GameObject>("Prefabs/fence"));
            this.CreatedMap(fence, this.fencesPos[i].x, this.fencesPos[i].y);
        }
 
        while (true)
        {
            this.mapTile = Instantiate(Resources.Load<GameObject>("Prefabs/tile"));
 
            this.mapTile.tag = "Tile";
 
            this.mapTile.transform.SetParent(this.transform);
 
            this.CreatedMap(this.mapTile, this.col, this.row);
 
            this.dicTiles.Add(new Vector2(col, row), mapTile);
            this.col++;
 
            if (this.col >= this.colCount)
            {
                this.col = 0;
                this.row++;
            }
 
            if (this.row >= this.rowCount)
            {
                row = 0;
                this.WorldToCenterCamera();
                break;
            }
        }
    }
 
    //맵생성
    private void CreatedMap(GameObject tileMap, float x, float y)
    {
        var vec2 = new Vector2(x, y);
 
        tileMap.AddComponent<TestTile>();
        tileMap.GetComponent<TestTile>().vec2 = vec2;
 
        if (tileMap.GetComponent<TestTile>().vec2 == this.buildingPos)
        {
            tileMap.GetComponent<TestTile>().isBuilding = true;
            this.villageNode = tileMap;
        }
 
        for (int a = 0; a < this.blockPos.Length; a++)
        {
            if (vec2 == this.blockPos[a])
            {
                tileMap.name = "block";
                tileMap.GetComponent<SpriteRenderer>().color = Color.red;
                tileMap.GetComponent<TestTile>().isBlock = true;
            }
        }
 
        for (int b = 0; b < this.fencesPos.Length; b++)
        {
            if (vec2 == this.fencesPos[b])
            {
                tileMap.name = "fence";
                tileMap.GetComponent<TestTile>().isFence = true;
                tileMap.GetComponent<TestTile>().capacity = 3;
            }
        }
 
        var screen = this.MapToScreen(vec2);
 
        var screenPos = Camera.main.ScreenToWorldPoint(new Vector2(screen.x, screen.y));
 
        tileMap.transform.position = new Vector3(screenPos.x, screenPos.y, 0);
    }
 
    //맵포지를 스크린포지로
    public Vector2 MapToScreen(Vector2 mapPos)
    {
        var screenX = mapPos.x * this.tileWidth - (mapPos.y * this.tileWidth);
        var screenY = mapPos.y * -tileHeight - (mapPos.x * tileHeight);
 
        return new Vector2(screenX, screenY);
    }
 
    //카메라를 타일의 센터로
    private void WorldToCenterCamera()
    {
        var pos = new Vector2(this.colCount / 2 - 1, this.rowCount / 2 - 1);
 
        var posX = this.dicTiles[pos].transform.position.x;
        var posY = this.dicTiles[pos].transform.position.y;
 
        Camera.main.transform.localPosition = new Vector3(posX, posY, -100);
        Camera.main.orthographicSize = this.rowCount / 2;
    }
    #endregion
}
Colored by Color Scripter
cs

변수 이름을 위한 명명 규칙
작성 규칙	예
첫번째 글자는 문자이거나 '$','_'이어야 하며 숫자는 사용불가	가능 : price, $price, _companyName 불가능 : 1v, @speed, $#value
영어 대소문자 구분이 된다	firstname 과 firstName 은 다른 변수
첫문자는 소문자로 시작하되, 다른 단어가 붙을경우 대문자로 한다	amxSpeed,firstName, carBodyColor
문자 수 제한이 없다
자바 예약어는 사용불가	기본 데이터 값, 접근지정자, 클래스 관련 등등...