어느 날  기획자가 공격자가 피격자 뒤에서 공격 하면 데미지를 더 준다 던지

명중률이 더 올라간다던지  피격자가 등 뒤에서 맞았는지 앞에서 맞았는지 요구 한다.

1 ) 피격자의 시야각을 설정한다.

2 ) 피격자와 공격자의 위치를 안다.

3 ) 피격자의 방향벡터를 안다.

이 세 가지만 알면 해결 할 수 있다.

모 피격자의 시야각은 xml로 뺀다든지 해서 기획자가 고칠 수 있게 해주자.

피격자 시야 각 120도

O : 피격자

A,B,C : 공격자

우선 O와 A,B,C의 위치를 알기 때문에

피격자와 공격자의 위치를 빼주면 피격자와 공격자 사이의 위치 벡터가 생긴다.

피격자의 방향벡터도 안다.

A - O = T1

B - O = T2

C - O = T3

피격자 방향 벡터 = T4

자 이제 피격자가 공격받은 방향을 판단 할 수 있는 기본 정보가 다  모였다.

내적의 성질을 이용하면 된다.

시야각이 120이 되어있는데 딱 절반으로 나두면 된다. 그럼 60도 가 나온다.

절반으로 나눈 이유는

내적했을 때 0-90도 360-270도, 90-180도 270-180도 대칭 값이다.

무슨 말이 냐면 45도나 315도를 내적하면 0.7071....이라는 같은 값이 나온다.

그러면 그냥 315도를 45도라 생각하면 된다. 이 성질을 이용하면

120도가 다 필요없다 딱 나눠서 60을 이용하면 된다.

결론

cos(60) = 0.5

if( 0.5 > 피격자 방향벡터 · 피격자와 공격자의 방향벡터 )

앞에서 맞았음

else

뒤어서 맞았음

이렇게 된다.

0.5 > T1 · T4 =  거짓 (뒤)

0.5 > T2 · T4 =  참 (앞)

0.5 > T3 · T4 =  참 (앞)

벡터의 길이

사진 출처 : 최신 선형 대수 ( 교보 문고 )

이차원의 벡터의 길이

sqrt( Ax * Ax  + Ay * Ay )

삼차원의 벡터 길이 z추가

sqrt( Ax * Ax  + Ay * Ay + Az * Az )

n차원의 벡터의 길이는

sqrt( Ax * Ax  + Ay * Ay + Az * Az ...  + An * An )

모든 축의 값을 제곱으로 곱하기 때문에

벡터의 길이는 양수만 나옴

단위 벡터

단위 벡터는 벡터의 길이가 1이다.

단위 벡터 만드는 방법은 벡터의 길이만큼을 벡터에 나눠 주면 된다.

단위 벡터 = 벡터 / 벡터의 길이

이 공식 대로 하면 된다.

예) (2,2,2)의 벡터를 단위벡터로

우선 길이를 구하자

2 * 2 + 2 *2 + 2 * 2 = 12

sqrt(12) = 3.46410

길이가 4가 나온다.

(2,2,2) / 3.46410 = ( 0.57735, 0.57735, 0.57735 )

(2,2,2) 의 단위벡터 값은 ( 0.57735, 0.57735, 0.57735 )

1) 모듈

C++의 #include 와 비슷하다고 생각하면 된다.

같은 폴더 안에 있을 경우에는

간단하게

import TestJaeho

이렇게 import시켜 주면 된다.

TestJaeho.py

def sum ( a, b):
    if type(a) != type(b):
        print ("%s와 %s는 같은 타입이 아니라 더할 수 없습니다." % (a,b))
        return
    else:
        return a+b

Test.py

import TestJaeho

print(TestJaeho.sum(5,625))
print(TestJaeho.sum('a','g'))
print(TestJaeho.sum('a',5))

>>> 630
>>> ag
>>> a와 5는 같은 타입이 아니라 더할 수 없습니다.

단 사용할려면 TestJaeho.sum 이런식으로 해줘야 한다.

정말 귀차니즘 발동 시킨다.

그냥 sum으로만 사용하고 싶을 시에는

또는

from TestJaeho import sum 

이렇게 하면 되는데

그냥 import *가 편할 듯 싶다.

다른 폴더에 있는 파일을 임포트 하고 싶을 때!!

우선

import sys

을 하자

sys.path를 실행해 보면

['C:\\Python', 'C:\\Program Files\\PyScripter\\Lib\\rpyc.zip', 'C:\\Windows\\system32\\python32.zip', 'C:\\Python32\\DLLs', 'C:\\Python32\\lib', 'C:\\Python32', 'C:\\Python32\\lib\\site-packages']

이렇게 나온다.

이경로에 있는 것들은 그냥 import 모듈이름  하면 쓸 수 있다.

그러니 sys.path에 내가 쓰고 싶은 폴더를 넣어주면 된다.

이렇게!!

import sys
sys.path.append("C:\Python\TestJaeho")
print (sys.path)

import moduleTest

이렇게 추가한다음 사용하면 된다.

if __name__ == "__main__"

보통은 자신의 모듈의 이름을 가지지만 파이썬 인터프리터에 의해 첫번째 사용 되는 모듈은

__main__이라는 이름을 가지게 된다.

두발인 인간형은 경사면을 걸어도 별로 어색하지 않다.

하지만 네발달린 동물이나 길죽하게 생긴 뱀등등 은 경사면을 움직일 때

경사면에 따라 회전하지 않으면 지형에 많이파묻히게 되어서 눈에 거슬린다.

그냥 쌩까도 되지만 난 해결하고 싶으니 GoGo

우선 해결 하기 위해선 벡터, 외적, 내적정도는 알아야 할듯

1 ) 오브젝트가 움직이는 방향 벡터 : A

2 ) 현재 오브젝트가 지나고 있는 지형의 노말 벡터 : B

R = HALF_PI -  acos( A · B /  ( A.Length * B.Length ) )

정말 쉽다. ㅎㅎㅎㅎ

R값을 자신이 구현하고 있는 좌표계에 맞춰서 오브젝트를 회전 시키면

경사각에 맞게 오브젝트가 아름답게 회전해서 이동을 한다.!!

단 R값을 바로 적용하면 아주 튀어보이니깐 델타값에 맞추서 서서히

적용시키는것이 아름답다!!

1 ) A · B = Ax * Bx + Ay * By + Az * Bz

2 ) A · B = ( A.Length * B.Length ) * cos(각도)

A와 B 벡터 내적을 표현 할 수 있는 식 두가지

즉 Ax * Bx + Ay * By + Az * Bz  =  ( A.Length * B.Length ) * cos(각도)

이렇게 표현 할수 있다.

내가 알고 싶은 것은 사이각 이므로

오른쪽에 있는 각도만 빼고 다 왼쪽으로 넘겨 버리면 된다.

Ax * Bx + Ay * By + Az * Bz  = A · B 이므로

acos( A · B /  ( A.Length * B.Length ) ) = 사이각

acos( A · B /  ( A.Length * B.Length ) ) 이 식을 이용하면 사이각을 구할 수 있다.

그리고 두 벡터가 노말라이즈가 된 벡터들이라면 acos( A · B ) 이렇게만 해도 된다.

하지만 이 식은 0 ~ 180 도 사이각만 알 수 있다.

0 ~ 360 도나 0 ~ 180, 0 ~ -180을 알고 싶을 때는 어떻게 하면 될까라는 궁금증이 생기게 되는데

A,B,C 벡터가 있다.

A와 B 의 사이각

A와 C 의 사이각

위 acos( A · B /  ( A.Length * B.Length ) ) 이 식에 대입하면 둘다 라디안 1.57값이 나오게 된다.

왜냐하면 cos에서  90도나 270도나 0이 나오기 때문이다. acos(0)을 넣으면 뱉아 내는 값이 1.57이다.

R = acos( A · B /  ( A.Length * B.Length ) )

Ax * By - Ay * Bx >= 0 ? R : -R

이렇게 z축 투영시키고 이차원 외적으로 구하면 0보다 크면 그냥 90도 0보다 작으면 - 90도 값이 나오게된다.

아니면

Ax * By - Ay * Bx >= 0 ? R : 360 - R

이러게하면 90도 270도가 나온다.

이 그래프하나로 설명된다. 쉽게 이해 할려고 라디안 되신 각도로 표시했다.

pass 1. 일단 오브젝트를 정상적으로 그립니다. 이때 깊이 테스트와 쓰기 모두 활성화 시킵니다.

Pass 2. 그리고는 오브젝트를 확대해서 그리되 라이팅을 끄고 검은색으로 뒷면을 그립니다.  이때 역시 깊이 테스트를 수행하기 때문에 확장 오브젝트의 뒷면 중 정상 오브젝트에 의하여 가려지는 부분은 걸러지기 때문에 오브젝트의 윤곽만 남게 됩니다.

pass 2 에서 오브젝트의 뒷면을 그리는 것은 Cull mode만 변경하면 되는 것이지만, 확장해서 그리는 것은 어떻게 하면 될까요? 단순히 모델 매트릭스의 스케일링만 조절하면 될 것 같지만 그렇지 않아요. 위 그림의 구체같은 단순한 모델은 문제가 없겠지만 아래와 같은 복잡한 모델은 문제가 생깁니다.
모델이 복잡한데다가 원점 또한 모델의 정 가운데 있지 않은 상태로 스케일링을 하면은

결과적으로 실루엣이 어긋나게 됩니다. 우리가 원했던 결과물이 아니지요.

그렇다면 어떻게 확장시키면 되는걸까요? 그것은 어렵지 않아요~ 모델의 정점을 노말 방향으로 조금만 이동해주면 되요~

이때, 고민이 하나 생기게 됩니다. 일정 크기로 모델을 확장해서 외곽선을 그리면 오브젝트와 카메라의 거리에 따라 외곽선의 두께 역시 일정치가 않게 보이는 것이죠. 오브젝트가 어디에 위치하든 일정한 두께로 보고 싶은데 말이죠. 하지만 그것도 어렵지~ 않아요~~ 다음 공식으로 사용하면 되요~

이미지 출처 : http://www.nocutnews.co.kr/show.asp?idx=465574

이미지 출처 : >>ㅑ~ 잼나는 건즈2 홍보 영상(http://www.youtube.com/watch?v=gUUtC901pw4) 

정반사는 입사벡터와 반사벡터의 크기가 같고, 입사각과 반사각의 크기가 같은것을 말한다.

Fig.1 을 보면 입사벡터 P 와 법선벡터 n 이 주어졌을때,
반사벡터 R 은 벡터 P 와 크기가 같고, 입사각과 반사각이
같음을 확인할 수 있다.
여기서는 P 와 n 만으로 반사벡터 R 을 구하는 방법을 알아보자.



 

 
우선, 입사 벡터 P 의 역벡터 -P 를 n 의 연장선상에 투영시켜
투영벡터 n(-P·n) 를 구한다.

입사 벡터 P 의 시작 위치를 원점에 위치시키고, 여기에 n(-P·n) 를 더하면, 입사면에 투영된 벡터의 위치를 구할수 있다.

Fig. 3 을 보면, 입사벡터 P 에 n(-P·n) 를 1번 더하면, 입사면에 투영된
위치를 구할 수 있고, 2번 더하면  반사벡터 R 을 구할 수 있음을
알수 있다.

결국, 반사벡터 R 은
R = P +  2n(-P·n)

출처 : http://toymaker.tistory.com/3 

이거를 기반으로 생각했을 땐

굴절 벡터는

B = P + ( 1 ~ 0.00001 )n(-P·n)

미끄럼 벡터는

S = P + n(-P·n)

1) 클래스

함수	설명	예제 (X, Y는 인스턴스)
__init__	생성자(Constructor), 인스턴스가 만들어 질 때 호출
__del__	소멸자(Destructor) 인스턴스가 사라질 때 호출
__add__	연산자 "+"	X + Y
__or__	연산자 "|"	X | Y
__repr__	print	print X
__call__	함수호출 X()했을 때 호출
__getattr__	자격부여	X.메소드
__getitem__	인덱싱	X[i]
__setitem__	인덱스 치환	X[key] = value
__getslice__	슬라이싱	X[i:j]
__cmp__	비교	X > Y

class FourCal():
    def __del__(self):
        print ("클래스가 죽었습니다.\n")
    def setNum( self, a, b ):
        self.first = a
        self.second = b
    def sum( self ):
        print ("%s + %s = %s\n" % (self.first,self.second,self.first+self.second))
    def mul( self ):
        print ("%s * %s = %s\n" % (self.first,self.second,self.first*self.second))
    def sub( self ):
        print ("%s - %s = %s\n" % (self.first,self.second,self.first-self.second))
    def div( self ):
        print ("%s / %s = %s\n" % (self.first,self.second,self.first/self.second))

test = FourCal()

test.setNum(9,3)

test.sum()
test.sub()
test.mul()
test.div()

9 + 3 = 12

9 - 3 = 6

9 * 3 = 27

9 / 3 = 3.0

다른 언어와 마찬가지로 클래스 사용법은 비슷하니 금방 익숙해질 듯 싶다.

기억해야 할것은 클래스 내 함수 사용시에는 반드시 ( self ) self을 넣어줘야한다.

파이썬 언어 특징이니 그냥 기억하면 될 듯 싶다.

연산자 오버로딩

class ChoHouse:
    lastName= "조"
    def __init__(self, name):
        self.FullName = self.lastName + name
    def __del__(self):
        print ("%s가 파산했습니다.\n" % self.FullName)
    def setMoney( self, money ):
        self.Money = money
        print ("%s의 지갑에 들어 있는 돈은 %s입니다.\n" % (self.FullName, self.Money))
    def __add__( self, you):
        print("%s가 %s한테 돈을 빌렸다.\n" % (self.FullName,you.FullName))
    def __sub__( self, you):
        print("%s가 %s한테 돈을 빌렸다.\n" % (you.FullName,self.FullName))

def input_int():
    return int( input("숫자 입력하세요") )

a = input_int()
b = input_int()
jaeho(a,b)

input()

이 함수를 사용하면 입력 받을 수 있는 창이 뜬다.

대신 모든 입력 받은건 문자형으로 받는다.

그래서 형변환이 필수!!!!!

3) 파일 읽고 쓰기

f = open("jaeho.txt",'w')
data=""
for i in range(1,11):
    data = data + "%d 번 째 줄입니다\n" % i

f.write(data)
f.close()

tell 과 seek
>>> f = open("test.txt", 'w')
>>> f.write("this is one line\n")
>>> f.write("two line\n")
>>> f.write("three line\n")
>>> f.close()
우선 test.txt라는 파일을 쓰기 모드로 열어서 파일 객체를 생성한후
write함수를 이용하여 총 세 개의 줄을 test.txt파일에 입력하고 파일 객체를 닫는다.

test.txt파일은 다음과 같을 것이다.
this is one line
two line
three line

다음의 예를 계속해서 따라해 보자.
>>> f = open("test.txt", 'r')
>>> f.tell()
0

처음에 파일을 읽기 모드로 열었고, 그 파일 포인터 값을 알기 위해서 tell을 호출하였다.
물론 파일의 맨 처음이기 때문에 0을 반환했다.
>>> f.readline()
'this is one line\n'
>>> f.tell()
17

다음에 한 줄을 읽는다. 그 다음의 파일 포인터는 그 줄의 바이트 수만큼 포인터가 증가한다.
따라서 다시 tell을 호출했을 때 17이 된 것이다.
>>> f.readline()
'two line\n'
>>> f.tell()
26

마찬가지로 다시 한 줄을 읽었더니 파일 포인터의 위치는 26이 되었다.
>>> f.seek(0)
>>> f.readline()
'this is one line\n'
>>>
파일 포인터의 값을 변화시키기 위해서 seek를 사용하였다.
f.seek(0)는 파일 포인터의 위치를 0으로 하라는 것이다.
따라서 다음에 다시 한 줄을 읽었을 때는 그 파일의 맨 처음 줄을 읽게 되는 것이다.

readline()

f = open("새파일.txt", 'r')

while 1:
    line = f.readline()
    if not line: break
    print line


f.close()

readlines()

f = open("새파일.txt", 'r')
lines = f.readlines()


for line in lines:
    print line

f.close()

read()

f = open("새파일.txt", 'r')
data = f.read()

print data

f.close()