Yang.공부방

[SVN] 폴더 제외

Unity/Study2019. 7. 10. 09:47

*.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 

C:\Users\user\Downloads\TestGPGS+개인정보+처리.html

TestGPGS+개인정보+처리.html


<시나브로>('https://yangjae.tistory.com/'이하 '시나브로')은(는) 개인정보보호법에 따라 이용자의 개인정보 보호 및 권익을 보호하고 개인정보와 관련한 이용자의 고충을 원활하게 처리할 수 있도록 다음과 같은 처리방침을 두고 있습니다.

<시나브로>('시나브로') 은(는) 회사는 개인정보처리방침을 개정하는 경우 웹사이트 공지사항(또는 개별공지)을 통하여 공지할 것입니다.

○ 본 방침은부터 2019613일부터 시행됩니다.


1. 개인정보의 처리 목적 <시나브로>('https://yangjae.tistory.com/'이하 '시나브로')은(는) 개인정보를 다음의 목적을 위해 처리합니다. 처리한 개인정보는 다음의 목적이외의 용도로는 사용되지 않으며 이용 목적이 변경될 시에는 사전동의를 구할 예정입니다.

가. 홈페이지 회원가입 및 관리

만14세 미만 아동 개인정보 수집 시 법정대리인 동의 여부 확인 등을 목적으로 개인정보를 처리합니다.


나. 재화 또는 서비스 제공

콘텐츠 제공, 본인인증 등을 목적으로 개인정보를 처리합니다.




2. 개인정보 파일 현황
('https://yangjae.tistory.com/'이하 '시나브로')가 개인정보 보호법 제32조에 따라 등록․공개하는 개인정보파일의 처리목적은 다음과 같습니다.

1. 개인정보 파일명 : TestGPGS 개인정보 처리방침
- 개인정보 항목 : 로그인ID, 성별, 생년월일
- 수집방법 : Google Api
- 보유근거 : 게임내에 유저정보 표시
- 보유기간 : 10년
- 관련법령 : 신용정보의 수집/처리 및 이용 등에 관한 기록 : 3년, 계약 또는 청약철회 등에 관한 기록 : 5년



※ 기타('https://yangjae.tistory.com/'이하 '시나브로')의 개인정보파일 등록사항 공개는 행정안전부 개인정보보호 종합지원 포털(www.privacy.go.kr) → 개인정보민원 → 개인정보열람등 요구 → 개인정보파일 목록검색 메뉴를 활용해주시기 바랍니다.

3. 개인정보의 처리 및 보유 기간

<시나브로>('시나브로')은(는) 법령에 따른 개인정보 보유·이용기간 또는 정보주체로부터 개인정보를 수집시에 동의 받은 개인정보 보유,이용기간 내에서 개인정보를 처리,보유합니다.

② 각각의 개인정보 처리 및 보유 기간은 다음과 같습니다.

1.<제화 또는 서비스 제공>
<제화 또는 서비스 제공>와 관련한 개인정보는 수집.이용에 관한 동의일로부터<10년>까지 위 이용목적을 위하여 보유.이용됩니다.
-보유근거 : 게임내에 재화 구매
-관련법령 : 1)신용정보의 수집/처리 및 이용 등에 관한 기록 : 3년
2) 계약 또는 청약철회 등에 관한 기록 : 5년

-예외사유 :



4. 개인정보의 제3자 제공에 관한 사항

<시나브로>('https://yangjae.tistory.com/'이하 '시나브로')은(는) 정보주체의 동의, 법률의 특별한 규정 등 개인정보 보호법 제17조 및 제18조에 해당하는 경우에만 개인정보를 제3자에게 제공합니다.

<시나브로>('https://yangjae.tistory.com/')은(는) 다음과 같이 개인정보를 제3자에게 제공하고 있습니다.


1. <시나브로>
- 개인정보를 제공받는 자 : 시나브로
- 제공받는 자의 개인정보 이용목적 : 로그인ID, 서비스 이용 기록, 접속 로그, 결제기록
- 제공받는 자의 보유.이용기간: 10년



5. 개인정보처리 위탁

<시나브로>('시나브로')은(는) 원활한 개인정보 업무처리를 위하여 다음과 같이 개인정보 처리업무를 위탁하고 있습니다.

1. <>
- 위탁받는 자 (수탁자) :
- 위탁하는 업무의 내용 :
- 위탁기간 :



<시나브로>('https://yangjae.tistory.com/'이하 '시나브로')은(는) 위탁계약 체결시 개인정보 보호법 제25조에 따라 위탁업무 수행목적 외 개인정보 처리금지, 기술적․관리적 보호조치, 재위탁 제한, 수탁자에 대한 관리․감독, 손해배상 등 책임에 관한 사항을 계약서 등 문서에 명시하고, 수탁자가 개인정보를 안전하게 처리하는지를 감독하고 있습니다.

③ 위탁업무의 내용이나 수탁자가 변경될 경우에는 지체없이 본 개인정보 처리방침을 통하여 공개하도록 하겠습니다.

6. 정보주체와 법정대리인의 권리·의무 및 그 행사방법 이용자는 개인정보주체로써 다음과 같은 권리를 행사할 수 있습니다.

① 정보주체는 시나브로에 대해 언제든지 개인정보 열람,정정,삭제,처리정지 요구 등의 권리를 행사할 수 있습니다.
② 제1항에 따른 권리 행사는시나브로에 대해 개인정보 보호법 시행령 제41조제1항에 따라 서면, 전자우편, 모사전송(FAX) 등을 통하여 하실 수 있으며 시나브로은(는) 이에 대해 지체 없이 조치하겠습니다.
③ 제1항에 따른 권리 행사는 정보주체의 법정대리인이나 위임을 받은 자 등 대리인을 통하여 하실 수 있습니다. 이 경우 개인정보 보호법 시행규칙 별지 제11호 서식에 따른 위임장을 제출하셔야 합니다.
④ 개인정보 열람 및 처리정지 요구는 개인정보보호법 제35조 제5항, 제37조 제2항에 의하여 정보주체의 권리가 제한 될 수 있습니다.
⑤ 개인정보의 정정 및 삭제 요구는 다른 법령에서 그 개인정보가 수집 대상으로 명시되어 있는 경우에는 그 삭제를 요구할 수 없습니다.
⑥ 시나브로은(는) 정보주체 권리에 따른 열람의 요구, 정정·삭제의 요구, 처리정지의 요구 시 열람 등 요구를 한 자가 본인이거나 정당한 대리인인지를 확인합니다.



7. 처리하는 개인정보의 항목 작성

<시나브로>('https://yangjae.tistory.com/'이하 '시나브로')은(는) 다음의 개인정보 항목을 처리하고 있습니다.



8. 개인정보의 파기<시나브로>('시나브로')은(는) 원칙적으로 개인정보 처리목적이 달성된 경우에는 지체없이 해당 개인정보를 파기합니다. 파기의 절차, 기한 및 방법은 다음과 같습니다.

-파기절차
이용자가 입력한 정보는 목적 달성 후 별도의 DB에 옮겨져(종이의 경우 별도의 서류) 내부 방침 및 기타 관련 법령에 따라 일정기간 저장된 후 혹은 즉시 파기됩니다. 이 때, DB로 옮겨진 개인정보는 법률에 의한 경우가 아니고서는 다른 목적으로 이용되지 않습니다.

-파기기한
이용자의 개인정보는 개인정보의 보유기간이 경과된 경우에는 보유기간의 종료일로부터 5일 이내에, 개인정보의 처리 목적 달성, 해당 서비스의 폐지, 사업의 종료 등 그 개인정보가 불필요하게 되었을 때에는 개인정보의 처리가 불필요한 것으로 인정되는 날로부터 5일 이내에 그 개인정보를 파기합니다.



9. 개인정보 자동 수집 장치의 설치•운영 및 거부에 관한 사항

시나브로 은 정보주체의 이용정보를 저장하고 수시로 불러오는 ‘쿠키’를 사용하지 않습니다.

10. 개인정보 보호책임자 작성


① 시나브로(‘https://yangjae.tistory.com/’이하 ‘시나브로) 은(는) 개인정보 처리에 관한 업무를 총괄해서 책임지고, 개인정보 처리와 관련한 정보주체의 불만처리 및 피해구제 등을 위하여 아래와 같이 개인정보 보호책임자를 지정하고 있습니다.


▶ 개인정보 보호책임자
성명 :양재준
직책 :대표
직급 :대표
연락처 :01034778267, wapffhs@naver.com,
※ 개인정보 보호 담당부서로 연결됩니다.

▶ 개인정보 보호 담당부서
부서명 :
담당자 :
연락처 :, ,
② 정보주체께서는 시나브로(‘https://yangjae.tistory.com/’이하 ‘시나브로) 의 서비스(또는 사업)을 이용하시면서 발생한 모든 개인정보 보호 관련 문의, 불만처리, 피해구제 등에 관한 사항을 개인정보 보호책임자 및 담당부서로 문의하실 수 있습니다. 시나브로(‘https://yangjae.tistory.com/’이하 ‘시나브로) 은(는) 정보주체의 문의에 대해 지체 없이 답변 및 처리해드릴 것입니다.



11. 개인정보 처리방침 변경

①이 개인정보처리방침은 시행일로부터 적용되며, 법령 및 방침에 따른 변경내용의 추가, 삭제 및 정정이 있는 경우에는 변경사항의 시행 7일 전부터 공지사항을 통하여 고지할 것입니다.



12. 개인정보의 안전성 확보 조치 <시나브로>('시나브로')은(는) 개인정보보호법 제29조에 따라 다음과 같이 안전성 확보에 필요한 기술적/관리적 및 물리적 조치를 하고 있습니다.

1. 개인정보의 암호화
이용자의 개인정보는 비밀번호는 암호화 되어 저장 및 관리되고 있어, 본인만이 알 수 있으며 중요한 데이터는 파일 및 전송 데이터를 암호화 하거나 파일 잠금 기능을 사용하는 등의 별도 보안기능을 사용하고 있습니다.

isometric

Unity/수업내용2019. 5. 12. 22:33

참고 : http://clintbellanger.net/articles/isometric_math/




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
using System.Collections;
using System.Collections.Generic;
using System.Text;
using UnityEngine;
using UnityEngine.UI;
 
public class Helloworld : MonoBehaviour
{
    public Button btn;
 
    private int tileWidth = 64;
    private int tileHeight = 64;
    private int col = 0;
    private int row = 0;
 
    void Start()
    {
        StringBuilder sb = new StringBuilder();
 
        btn.onClick.AddListener(() =>
        {
            this.CreateTile(col, row);
            col++;
            if(col >= 3)
            {
                col = 0;
                row++;
            }
 
            if (col == 0 && row ==3)
            {
                var textPos = this.btn.transform.position;
                this.btn.gameObject.SetActive(false);
            }
        });
    }
 
    private void CreateTile(float x, float y)
    {
        var tile = Instantiate(Resources.Load<GameObject>("64x64"));
        
        var map = new Vector2(x, y);
        
        tile.GetComponentInChildren<TextMesh>().text = string.Format("({0},{1})", x, y);
 
        var screen = this.MapToScreen(map);
 
        var worldPos = Camera.main.ScreenToWorldPoint(new Vector2(screen.x + 512 - 512, screen.y + 384 + 384));
 
        tile.transform.position = new Vector3(worldPos.x, worldPos.y, 0);
    }
 
    public Vector2 MapToScreen(Vector2 mapPos)
    {
        var screenX = mapPos.x * tileWidth;
        var screenY = -mapPos.y * tileHeight;
 
        return new Vector2(screenX, screenY);
    }
}
 
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
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
 
public class TestIsoTile : MonoBehaviour
{
    public Button btn;
 
    private int tileWidth = 64;
    private int tileHeight = 32;
    private int col = 0;
    private int row = 0;
 
    void Start()
    {
        this.btn.onClick.AddListener(()=>
        {
            CreateTile(col, row);
            col++;
 
            if(col >=3)
            {
                col = 0;
                row++;
            }
 
            if (col == 0 && row == 3)
            {
                var textPos = this.btn.transform.position;
                this.btn.gameObject.SetActive(false);
            }
        });
    }
 
    private void CreateTile(float x, float y)
    {
        var tile = Instantiate(Resources.Load<GameObject>("isoTile"));
 
        var map = new Vector2(x, y);
 
        tile.GetComponentInChildren<TextMesh>().text = string.Format("({0},{1})", x, y);
 
        var screen = this.MapToScreen(map);
 
        var screenPos = Camera.main.ScreenToWorldPoint(new Vector2(screen.x + 512, screen.y + 384));
        
        tile.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);
    }
 
    public Vector2 ScreenToMap(Vector2 screenPos)
    {
        //128,64 ->(2,1)
        var screenX = (int)screenPos.x / tileWidth;
        var screenY = (int)screenPos.y / tileHeight;
 
        return new Vector2(screenX, screenY);
    }
}
 
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
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.EventSystems;
 
public class TestIsoTile : MonoBehaviour
{
    public Button btn;
 
    public int colCount;
    public int rowCount;
 
    private GameObject tile;
    private int tileWidth = 64;
    private int tileHeight = 32;
    private int col = 0;
    private int row = 0;
    private Coroutine routine;
    
    void Start()
    {
        this.btn.onClick.AddListener(() =>
        {
            while (true)
            {
                CreateTile(this.col, row);
                this.col++;
 
                if (this.col >= this.colCount)
                {
                    this.col = 0;
                    this.row++;
                }
                if (this.row >= this.rowCount)
                {
                    //this.btn.gameObject.SetActive(false);
                    row = 0;
                    break;
                }
            }
        });
 
        this.TileCheck();
    }
 
    private void Update()
    {
        
    }
 
    void TileCheck()
    {
        if(routine != null)
        {
            StopCoroutine(this.routine);
        }
        this.routine = StartCoroutine(this.TileCheckImpl());
    }
 
    IEnumerator TileCheckImpl()
    {
        while (true)
        {
            if (Input.GetMouseButtonDown(0))
            {
                Vector2 worldPos = Camera.main.ScreenToWorldPoint(Input.mousePosition);
 
                RaycastHit2D hit = Physics2D.Raycast(worldPos, Vector2.zero);
 
                if (hit.collider != null)
                {
                    Debug.Log(hit.collider.GetComponentInChildren<TextMesh>().text);
                }
            }
            yield return null;
        }
    }
 
    private void CreateTile(float x, float y)
    {
        this.tile = Instantiate(Resources.Load<GameObject>("isoTile"));
 
        this.tile.tag = "Tile";
 
        var isometric = GameObject.Find("isometricList");
 
        this.tile.transform.SetParent(isometric.transform);
 
        var map = new Vector2(x, y);
 
        this.tile.GetComponentInChildren<TextMesh>().text = string.Format("({0},{1})", x, y);
 
        var screen = this.MapToScreen(map);
 
        var screenPos = Camera.main.ScreenToWorldPoint(new Vector2(screen.x + 512, screen.y + 384));
 
        this.tile.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);
    }
}
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
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
 
public class TestCharacter : MonoBehaviour
{
    public Button btn;
    public Button btn2;
    public TestJump player;
    public GameObject gem;
    public Image gemUI;
    public Image gemClone;
    public float speed;
 
    private int value;
    
    void Start()
    {
        this.btn.onClick.AddListener(() =>
        {
            Debug.Log("버튼클릭");
            this.player.jump();
        });
 
        this.btn2.onClick.AddListener(() =>
        {
            Debug.Log("버튼2클릭");
            var viewportPoint = Camera.main.WorldToViewportPoint(this.gem.transform.position);
            var screenPoint = Camera.main.WorldToScreenPoint(this.gem.transform.position);
 
            Debug.LogFormat("viewPort:{0}", viewportPoint);
            Debug.LogFormat("{0}, {1}", screenPoint.x - 1024 / 2, screenPoint.y - 768 / 2);
        });
    }
 
    IEnumerator GetGem()
    {
        while (true)
        {
            var dir = (this.gemUI.transform.position - this.gemClone.transform.position).normalized;
            var distance = Vector3.Distance(this.gemUI.transform.position, this.gemClone.transform.position);
 
            this.gemClone.transform.position += dir * speed * Time.deltaTime;
 
            yield return null;
            
            if (distance <= 6f)
            {
                Debug.Log("이동완료");
                this.gemClone.enabled = false;
                this.value += 1;
                GameObject.FindObjectOfType<Text>().text = this.value.ToString();
                break;
            }
        }
 
        yield return new WaitForSeconds(1.5f);
        
        this.gem.SetActive(true);
 
        if(gem.activeSelf == true)
        {
            var screenPoint = Camera.main.WorldToScreenPoint(this.gem.transform.position);
            this.gemClone.transform.position = screenPoint;
            this.gemClone.enabled = true;
        }
    }
 
    void Update()
    {
 
    }
 
    private void OnTriggerEnter2D(Collider2D collision)
    {
        Debug.LogFormat("{0}", collision.name);
 
        if (collision.gameObject.tag == "Gem")
        {
            this.gem.SetActive(false);
            StartCoroutine(this.GetGem());
        }
    }
}
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
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
 
public class TestJump : MonoBehaviour
{
    public float jumpHeight;
    public float gravity;
    private Vector2 dir;
    private Coroutine rountine;
 
    public void jump()
    {
        if(this.rountine != null)
        {
            StopCoroutine(this.rountine);
        }
        this.rountine = StartCoroutine(this.JumpImpl());
    }
 
    private IEnumerator JumpImpl()
    {
        Debug.Log("jump실행");
        this.dir.y = this.jumpHeight;
        
        while (true)
        {
            this.dir.y -= gravity * Time.deltaTime;
            this.transform.Translate(dir * Time.deltaTime);
 
            if (this.transform.position.y <= 0)
            {
                this.transform.position = Vector2.zero;
                break;
            }
            yield return null;
        }
    }
}
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
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
 
public class TestSunnyLand : MonoBehaviour
{
    public Button idleBtn;
    public Button runBtn;
    public Button jumpBtn;
 
    public float backgroundSpeed;
    public float groundSpeed;
    public float treeSpeed;
    public Transform background;
    public Transform ground;
    public Transform[] arrTree;
    Vector3 backGroundPosition;
    Vector3 groundPosition;
    private float backGroundSize = 3.65f;
    private float treeSize = 7f;
 
    private bool isMove = false;
 
    private void Start()
    {
        this.backGroundPosition = this.background.transform.position;
        this.groundPosition = this.ground.transform.position;
    }
 
    void Update()
    {
        var anim = GetComponent<Animator>();
 
        idleBtn.onClick.AddListener(() =>
        {
            this.isMove = false;
            anim.Play("player_idle");
        });
        runBtn.onClick.AddListener(() =>
        {
            this.isMove = true;
            anim.Play("player_run");
            //StartCoroutine(this.AngleMove());
        });
        jumpBtn.onClick.AddListener(() =>
        {
            this.isMove = true;
            anim.Play("player_jump");
        });
    }
    
 
    private void FixedUpdate()
    {
        if (this.isMove == true)
        {
            var newPosition = Mathf.Repeat(Time.time * backgroundSpeed, backGroundSize);
            var treeNewPosition = Mathf.Repeat(Time.time * backgroundSpeed, backGroundSize);
 
            this.background.transform.position = this.backGroundPosition + Vector3.right * newPosition;
            this.ground.transform.position = this.groundPosition + Vector3.left * newPosition;
 
            for (int i = 0; i < arrTree.Length; i++)
            {
                var treeTrans = this.arrTree[i];
                this.arrTree[i].Translate(Vector3.left * treeSpeed * Time.deltaTime);
                if (treeTrans.transform.localPosition.x <= -1f)
                {
                    treeTrans.transform.localPosition = new Vector3(4.6f, -0.17f, 0);
                }
            }
        }
    }
}
cs