개발자의 일상

브리츠 BZ-T900BT 올인원 사운드바

잼스뻔 — Tue, 30 Jun 2026 12:32:42 +0900

브리츠 공식 유통사 (주)민트탭스로부터 제품을 제공받아 작성하였습니다

게임 개발자로 일하다 보니 하루의 대부분을 컴퓨터 앞에서 보내고 있습니다. 업무 중에는 이어폰을 착용하는 시간이 많지만, 주말만큼은 귀 건강을 생각해 주로 PC 스피커를 사용합니다. 또한 게임은 물론 유튜브와 넷플릭스 같은 영상 콘텐츠도 자주 즐기는 편이라 스피커의 활용도가 높은 편입니다.

이번 체험단을 통해 브리츠 BZ-T900BT 유무선 올인원 사운드바로 교체하게 되었습니다. 며칠 동안 직접 사용해 보니 디자인은 물론 음질과 연결 편의성까지 전반적으로 만족스러웠고, 좋은 PC 스피커가 사용 환경에 얼마나 큰 차이를 만들어 주는지 다시 한번 느낄 수 있었습니다.
그럼 지금부터 브리츠 BZ-T900BT 유무선 올인원 사운드바의 외형과 주요 기능, 그리고 실제 사용하면서 느낀 장점들을 하나씩 자세히 소개해 보겠습니다.

브리츠 BZ-T900BT는 크라프트지 박스로 한 번 더 포장되어 더욱 안전하게 보호하고 있습니다.

제품 박스에는 1년 무상보증 정품 씰이 부착되어 있으며, 제품의 주요 특징과 기능이 소개되어 있습니다.

구성품은 브리츠 BZ-T900BT본체, 사용자가이드, USB Type-C to Type-C케이블, USB 젠더(A Type), 3.5mm AUX 케이블로 구성되어 있습니다.

사용자 가이드에는 제품 스펙과 사용 시 주의사항, 제품 보증서(1년 무상 보증)는 물론 연결 및 사용 방법까지 자세하게 설명되어 있습니다.

브리츠 BZ-T900BT를 처음 본 순간 깔끔한 화이트 디자인이라 어느 공간에서 있어서 잘 어울리겠다는 생각이 가장 먼저 들었습니다.
제품 전면에는 BZ-T900BT를 제어 가능한 올인원 인터페이스가 보입니다. 사운드와 조명을 제어할 수 있는 터치 패널, 전원 및 볼륨을 조절하는 다이얼 디자인의 노브가 탑재되어 있습니다. M(모드) 버튼을 누르면 PS / PC / 블루투스 / Line-In(AUX) / Optical(광) 5가지 연결방식이 순서대로 변경됩니다. EQ 버튼 또한 토글방식으로 게이밍 / 뮤직 / 무비 3가지 모드가 순서대로 변경됩니다. RGB버튼으로 12가지 RGB LED 모드를 설정할 수 있으며 더블터치를 하면 조명을 끄고 켤수 있습니다.
제품 후면에는 USB Type-C 포트, Opticla 포트, AUX 입력 단자가 마련되어 있어 다양한 기기와 연결할 수 있습니다.

평소 가장 오래 머무르는 제 작업 공간에 브리츠 BZ-T900BT를 배치해본 모습입니다.

화이트 컬러 디자인이라 책상이 더욱 깔끔하고 세련된 느낌이 들었습니다.

PC에 연결한 상태에서 직접 촬영한 영상입니다.
영상에서는 전원 및 볼륨 조절, EQ 모드(게이밍·뮤직·무비), 12가지 RGB LED 조명 효과, LED On/Off 기능 등을 확인할 수 있습니다.
영상만으로는 실제 사운드의 크기와 음질을 모두 전달하기 어려운 점이 조금 아쉽지만, 정격 20W 출력의 음역대별 섬세한 사운드를 직접 들어본 느낌은 상당히 인상적이었습니다. 최대 볼륨에서는 사무실 전체를 충분히 채울 만큼 강력한 출력이 느껴졌으며, 음량을 높여도 잡음이나 음의 찢어짐 없이 깔끔하고 풍부한 사운드를 들려주었습니다.
영상에는 담지 못했지만, 내장 마이크 기능도 테스트해 본 결과 음성 채팅과 간단한 화상회의 용도로 무리 없이 사용할 수 있을 만큼 정상적으로 잘 작동했습니다.

아이폰과 안드로이드 스마트폰에서 직접 블루투스 연결 및 사용도 해보았습니다. 스마트폰의 설정 > 블루투스 메뉴에서 검색되는 BZ-T900BT를 선택하기만 하면 바로 연결되어 사용 방법이 매우 간단했습니다.
사무실 끝과 끝, 제법 거리가 있는 환경에서 테스트해봤는데, 블루투스 5.4를 지원해서인지 끊김 없이 안정적으로 잘 연결되었습니다.

브리츠 BZ-T900BT는 화이트 컬러를 적용한 깔끔하고 세련된 디자인이 인상적인 제품이었습니다. 책상 위에 설치하는 것만으로도 작업 공간의 분위기가 한층 밝고 고급스러워지는 느낌을 받을 수 있었으며, 뛰어난 디자인뿐만 아니라 풍부하고 선명한 사운드까지 더해져 전체적인 만족도가 매우 높았습니다.

- 가장 기대했던 부분은 역시 게임에서의 성능이었습니다. FPS 게임에서는 발소리와 효과음이 또렷하게 전달되어 방향을 파악하기 쉬웠고, RPG 게임에서는 배경음악과 환경음이 더욱 풍성하게 표현되어 몰입감이 한층 높아졌습니다. 20W 출력은 책상에서 사용하는 PC 스피커로는 충분한 수준이었으며, 볼륨을 크게 높여도 음이 찢어지거나 잡음이 발생하지 않아 만족스러웠습니다. 특히 최대 볼륨에서는 사무실 공간을 충분히 채울 만큼 강력한 출력이 인상적이었습니다.

- 게임뿐만 아니라 음악 감상과 영화 시청에서도 만족스러운 성능을 보여주었습니다. 보컬은 또렷하게 표현되고 저음도 탄탄하게 받쳐주어 다양한 장르의 음악을 편안하게 감상할 수 있었습니다. 영화를 시청할 때는 대사가 선명하게 전달되고 효과음의 공간감도 잘 표현되어 모니터 내장 스피커와는 확실한 차이를 느낄 수 있었습니다. 또한 게이밍, 뮤직, 무비 EQ 모드를 지원해 콘텐츠에 맞춰 손쉽게 사운드 특성을 변경할 수 있다는 점도 편리했습니다.

평소 운동할 때는 브리츠 SaintRun5 오픈형 블루투스 이어폰을 사용하고 있는데, 개인적으로 브리츠 제품은 다른 브랜드에 비해 저음 표현이 탄탄하고 전체적으로 묵직하면서도 풍성한 사운드를 들려준다는 인상을 받아왔습니다. 이번에 사용한 브리츠 BZ-T900BT 역시 이러한 브랜드의 사운드 성향을 잘 이어가고 있다는 느낌을 받았습니다. 저음이 과하지 않으면서도 단단하게 받쳐주어 전체적인 음질이 편안하고 고급스럽게 느껴졌으며, 영화에서는 공간감이 살아나고 게임에서는 타격감과 몰입감이 더욱 향상되는 것을 체감할 수 있었습니다.

- 사용한 지 한참 지난 뒤에야 알게 된 기능이 하나 있었는데, 바로 내장 마이크였습니다. 처음에는 단순한 사운드바라고만 생각했는데, 디스코드 음성 채팅이나 간단한 화상회의를 진행할 때 별도의 마이크를 연결하지 않아도 사용할 수 있어 상당히 편리했습니다. 실제로 화상회의에서 테스트해 본 결과 음성이 또렷하게 전달되었으며, 일상적인 대화나 온라인 회의 용도로 사용하기에는 부족함이 없었습니다.

브리츠 BZ-T900BT는 책상 공간을 깔끔하게 정리하면서도 풍부한 사운드를 원하는 분, 게임과 영화, 음악을 하나의 스피커로 모두 만족스럽게 즐기고 싶은 분, 그리고 다양한 기기를 연결해 활용할 수 있는 실용적인 PC 사운드바를 찾는 분들에게 추천드리고 싶은 제품입니다. 세련된 디자인과 안정적인 성능, 다양한 편의 기능까지 고루 갖춘 만큼 데스크 환경을 한 단계 업그레이드하고 싶은 분들에게 만족스러운 선택이 될 것이라 생각합니다.

제품 링크

https://mkt.shopping.naver.com/link/69cf692ef4b67c7bad8afbc8

브리츠 BZ-T900BT | 마이크내장 PC 블루투스 사운드바 : Britz 공식 스토어

마이크 내장 / 블루투스 5.4 무선 연결 / 20W 고출력 / 5in1 멀티입력 / PC·TV·노트북 호환

mkt.shopping.naver.com

#브리츠 #T900BT #PC사운드바 #올인원스피커 #무선스피커 #블루투스스피커 #브리츠스피커 #사운드바 #Britz #PC스피커

인텔 코어 울트라5 시리즈2 250K Plus와 GIGABYTE B860M GAMING X 피씨디렉트

잼스뻔 — Mon, 29 Jun 2026 02:29:22 +0900

GIGABYTE 공식 유통사 PCDIRECT의 필드 테스트 이벤트를 통해 제품을 제공받아 작성하였습니다.

인텔 코어 울트라7 시리즈2 265K와 Z890 조합으로 작업 및 게이밍용 메인 PC를 만족스럽게 사용하고 있는 사용자로서, 최근 새롭게 출시된 애로우레이크 리프레시 250K Plus와 270K Plus가 뛰어난 성능과 합리적인 가격으로 많은 관심을 받고 있어 개인적으로도 기대가 컸습니다. 마침 이번 체험단에 선정되어 직접 사용해볼 기회를 얻게 되었습니다.
그럼 지금부터 인텔 코어 울트라7 시리즈2 250K Plus와 GIGABYTE B860M GAMING X 피씨디렉트를 자세히 살펴보겠습니다.

1. 제품소개

포장 박스에는 인텔 정품 스티커가 부착된 것을 확인 할수 있는데, 인텔에서 공식 지정한 PCDIRECT(피씨디렉트) 정품 CPU임을 알 수 있는데 3년 무상 AS가 가능합니다. 구성품은 인텔 코어 울트라5 시리즈2 250K Plus CPU, 가이드 등이 있습니다.

간단히 주요 스펙을 살펴보면, P코어 6개와 E코어 12개로 구성되어 있으며 총 18코어 18스레드를 지원합니다. 프로세서 기본 전력은 125W, 최대 터보 전력은 159W이며, DDR5 메모리는 최대 7200MT/s까지 지원합니다.
또한 내장 그래픽을 탑재하고 있어 외장 그래픽카드에 문제가 발생했을 때도 화면 출력이 가능해 시스템 점검이나 문제 해결이 편리합니다. 그래픽카드를 A/S 보내는 동안에도 내장 그래픽을 활용해 컴퓨터를 계속 사용할 수 있다는 점 역시 큰 장점입니다.

테스트에 사용할 GIGABYTE B860M GAMING X 피씨디렉트 메인보드입니다.
박스 전면에는 피씨디렉트(PCDIRECT) 정품임을 확인할 수 있는 3년 A/S 보증 스티커가 부착되어 있으며, 후면에서는 GIGABYTE B860M GAMING X의 주요 특징과 지원 기능을 확인할 수 있습니다.
구성품은 메인보드를 비롯해 사용자 가이드, SATA 케이블 2개, M.2 고무 패드 1팩 등으로 구성되어 있습니다. 패키지 구성은 상당히 심플한 편인데, 불필요한 부속품을 줄이는 대신 메인보드 자체의 품질과 성능에 더욱 집중한 것으로 보입니다.

블랙 PCB를 기반으로 화이트와 실버 컬러의 전원부 및 M.2 SSD 히트싱크를 적용해 세련된 디자인을 완성했습니다. 블랙과 화이트 콘셉트의 모든 시스템에 잘 어울리는 디자인으로, 첫인상이 상당히 만족스러웠습니다.

보조전원은 8핀이며, 전원부 8+1+2 페이즈 전원부와 방열판이 구성되어 있습니다.

전원부에는 합리적인 사이즈의 방열판이 있어서 발생하는 열을 쿨링하기에 충분한 크기이며 어느 정도의 오버클럭을 상태로 사용하더라도 믿음직해 보입니다.

왼쪽에서 부터 USB2.0/1.1 포트4개, HDMI 포트/DP 포트, 최대 40Gbps전송속도의 USB4 Type-C포트, USB BIOS 포트/USB3.2 Gen1 포트(파란색), USB3.2 Gen1 Type-A 2개(파란색), 리얼텍 2.5Gbe Lan(RTL8125D), 마이크, 오디오 포트(ALC897) 등이 있습니다.

그래픽카드가 점점 커지고, 특히 수랭 쿨러가 아닌 공랭 쿨러를 장착했을 경우, 손이 잘 닿지 않아서 그래픽카드를 분리하기가 쉽지 않은데, PCIe EZ-Latch 설계로 손잡이 부분이 조립에는 불편하지 않을정도의 최대크기로 제작되어, PCIe 슬롯에서 그래픽카드를 안전하고 쉽게 분리 가능합니다.

최대 9200 MHz 지원하는 DDR5 슬롯은 4개이며, 최대 용량 256GB, XMP 메모리 프로필을 지원합니다.

M.2 NVMe 슬롯 2개와 SATA3 포트 4개 지원으로, 저장 공간이 많이 필요한 분에게 포트를 넉넉하게 지원합니다.

CPU_FAN를 포함하여 4핀 팬 포트 3개가 있고, 5V 3핀 ARGB 포트가 3개가 있어서, 팬의 LED 모드와 컬러를 취향에 맞게 튜닝할 수 있습니다.

2. 조립 및 테스트 환경

인텔 코어 울트라5 250K Plus를 메인보드에 설치합니다.

SSD 히트싱크를 열고, 키오시아 EXCERIA PLUS G4 M.2 NVMe를 설치합니다.

메인보드에 CPU쿨러와 램을 차례대로 설치한 모습입니다.

듀얼타워의 큰 CPU쿨러를 사용하더라도, 전원부나 램과의 간섭 걱정은 없겠습니다.

설치완료한 모습입니다. PC케이스와의 간섭 걱정이 없어서 PC케이스 선택의 폭이 넓습니다.테스트에 사용하는 그래픽카드는 PCI 슬롯 3개의 두께이며, 최대 슬롯 3.5개 두께의 그래픽카드까지도 무난하게 설치가 가능합니다.

윈도우를 설치 후 부팅하면 GIGABYTE Control Center 알림이 우하단 팝업으로 뜨는데 그대로 설치를 진행하면 시스템에 필요한 드라이버와 소프트웨어를 손쉽게 설치할 수 있게 도와줍니다.

바이오스에서 하던 CPU, RAM, 팬속도 설정을 윈도우에서 손쉽게 할수 있습니다. 또한 메인보드에 연결된 LED의 RGB 색상을 변경하여 본인의 취향에 맞게 튜닝이 가능합니다.

메인보드 공식 홈페이지에 등록된 최신 BIOS 버전인 F11으로 업데이트를 진행했습니다.
BIOS 업데이트는 GIGABYTE Control Center(GCC) 소프트웨어를 통해 간편하게 진행할 수 있으며, FAT32로 포맷한 USB 메모리에 다운로드한 BIOS 파일을 저장한 뒤 부팅 시 DEL 키를 눌러 BIOS에 진입하면 업데이트할 수도 있습니다.

GIGABYTE B860M GAMING X 바이오스 F6버전일때는 아래 스샷처럼 스펙 성능의 10%도 나오지 않았지만, F11버전 업데이트 이후 정상적으로 사용할 수 있었습니다.

기본 설정인 Intel Default Setting - Performance을 그대로 두었으며, 테스트에 사용하는 램 메모리 XMP(6000 CL30)만 설정하고 테스트를 진행했습니다.

3. 벤치마크

CPU-Z를 통해 BIOS에서 설정한 값이 정상적으로 적용되어 동작하는 것을 확인했습니다.
CPU-Z 벤치마크 결과 싱글 코어 838.8점, 멀티 코어 13,740.0점을 기록했습니다. 특히 한때 최상위 모델로 높은 성능을 자랑했던 i9-12900K를 뛰어넘는 성능을 보여주어, 메인스트림 제품임에도 상당히 뛰어난 성능을 갖춘 것을 확인할 수 있었습니다.

크리스탈 디스크마크를 이용해 첫 번째 M.2 슬롯에 장착 KIOXIA EXCERIA PLUS G4 NVMe M.2 1TB SSD의 성능을 측정했습니다.
테스트 결과, 첫 번째 M.2 슬롯에 적용된 두꺼운 SSD 히트싱크가 발열을 효과적으로 제어해 주었으며, PCIe 5.0 인터페이스의 성능을 안정적으로 끌어내는 모습을 확인할 수 있었습니다.

또한 메인보드의 전면 USB Type-C 헤더와 연결된 PC 케이스의 USB Type-C 포트에 외장 SSD를 연결해 테스트한 결과, 해당 포트에서도 외장 SSD의 최대 성능이 정상적으로 지원되는 것을 확인했습니다.

CINEBECH R23 프로그램 싱글 2285점, 멀티 1회 31179점, 10분 31141점, 30분 30839점의 결과가 나왔습니다.

평소 31~35도로 측정되었으며, 30분 풀로드 상태에서 최대 81도가 측정되었습니다.

PCMARK 10 테스트 결과입니다.

3DMARK 파이어 스트라이크와 타임 스파이 실행결과입니다.

4. 마무리

인텔 코어 울트라5 시리즈2 250K Plus와 GIGABYTE B860M GAMING X 피씨디렉트에 대해서 살펴보고, 조립 및 테스트를 해보았습니다.

- CPU-Z 벤치마크에서는 한때 최상위 모델이었던 Core i9-12900K를 뛰어넘는 성능을 확인할 수 있었습니다. 또한 Cinebench R23을 30분 동안 연속 실행한 풀로드 테스트에서도 온도가 안정적으로 유지되어 보급형 공랭 쿨러만으로도 충분한 냉각 성능을 보여주었습니다. 울트라5 등급의 제품임에도 이전 세대 i7급에 준하는 뛰어난 성능을 제공해 작업용 시스템으로도 매우 만족스러웠으며, 수랭 쿨러 대신 공랭 쿨러를 선호하는 사용자에게도 좋은 선택지가 될 것으로 생각됩니다.
- 3DMark 테스트에서는 CPU 사용률이 약 50~60% 수준에 머무르면서도 Radeon RX 9070 XT를 100%에 가깝게 활용하는 모습을 보여주어 게이밍 성능 역시 만족스러웠습니다.

이번 리뷰가 새롭게 PC를 조립하거나 시스템 업그레이드를 계획하고 계신 분들께 조금이나마 도움이 되었기를 바랍니다.

구매링크

인텔 코어 울트라7 시리즈2 250K Plus : https://prod.danawa.com/info/?pcode=108424451

GIGABYTE B860M GAMING X 피시디렉트 : https://prod.danawa.com/info/?pcode=122669173

#GIGABYTE #PCDIRECT #기가바이트 #피씨디렉트 #인텔 #250K #250KPLUS #B860 #작업용PC #메인보드추천

[게임알고리즘] 9강 ~ 12강 코딩 테스트 및 실무 면접 대비

잼스뻔 — Tue, 16 Jun 2026 11:04:18 +0900

주 3시간, 총 12~13주 과정으로 구성되어 있어 실무에서 자주 활용되는 알고리즘 학습과 코딩 테스트, 실무 면접 준비까지 충분히 다룰 수 있을 것으로 기대했습니다. 다만 주 1회 수업으로 인해 공백 기간 때문에 학습의 연속성이 떨어지는 점, 대학에서 처음으로 진행한 강의인 만큼 시간을 효율적으로 활용하지 않은 점 등으로 전체 내용을 다루기에는 다소 시간이 부족하게 느껴졌습니다.

5월 22일 ~ 6월 5일 : 출시된 입사 문제 풀이 및 실무 면접을 다루었습니다.

6월 12일 : 개인적으로 취약한 점을 고려해서, 문제를 푸는 방법을 학습했습니다.

입사 문제는 e-Class 수업자료실에 업로드해두겠습니다.

[게임알고리즘] 8강 재귀와 반복

잼스뻔 — Tue, 16 Jun 2026 11:03:39 +0900

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

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
 
//#define xprintf printf
#define xprintf //printf
 
struct Rect
{
    int x, y, width, height;
};
 
Rect RectMake(int x, int y, int width, int height)
{
    Rect r;
    r.x = x;
    r.y = y;
    r.width = width;
    r.height = height;
    return r;
}
 
typedef unsigned char uint8;
Rect common(int* array, int wNum, int hNum, uint8* visit);
 
 
Rect click(int* array, int wNum, int hNum, int x, int y)
{
    int whNum = wNum * hNum;
    uint8* visit = (uint8*)calloc(sizeof(uint8), whNum);
    visit[wNum * y + x] = 1;
    return common(array, wNum, hNum, visit);
}
 
Rect drag(int* array, int wNum, int hNum, Rect rt)
{
    int whNum = wNum * hNum;
    uint8* visit = (uint8*)calloc(sizeof(uint8), whNum);
    for(int i=rt.x; i<rt.x+rt.width; i++)
    {
        for(int j = rt.y; j<rt.y+rt.height; j++)
            visit[wNum * j + i] = 1;
    }
    return common(array, wNum, hNum, visit);
}
 
Rect common(int* array, int wNum, int hNum, uint8* visit)
{
    while(1)
    {
        bool exist = false;
        for(int j=0; j<hNum; j++)
        {
            for(int i=0; i<wNum; i++)
            {
                int n = wNum * j + i;
                if( visit[n]==1 )
                {
                    visit[n] = 2;
                    xprintf("visit(%d, %d)\n", i, j);
#define canVisit(n) array[n] && visit[n]==0
                    if( i>0 && canVisit(n-1) ) visit[n-1] = 1;
                    if( i<wNum-1 && canVisit(n+1) ) visit[n+1] = 1;
                    if( j>0 && canVisit(n-wNum) ) visit[n-wNum] = 1;
                    if( j<hNum-1 && canVisit(n+wNum) ) visit[n+wNum] = 1;
#undef canVisit
                    exist = true;
                }
            }
        }
        if( exist==false )
            break;
    }
 
    int left;
    for(int i=0; i<wNum; i++)
    {
        bool exist = false;
        for(int j=0; j<hNum; j++)
        {
            if( visit[wNum * j + i] )
            {
                left = i;
                xprintf("found left = %d\n", i);
                exist = true;
                break;
            }
        }
        if( exist )
            break;
    }
    int right;
    for(int i=wNum-1; i>-1; i--)
    {
        bool exist = false;
        for(int j=0; j<hNum; j++)
        {
            if( visit[wNum * j + i] )
            {
                right = i;
                xprintf("found right = %d\n", i);
                exist = true;
                break;
            }
        }
        if( exist )
            break;
    }
    int top;
    for(int j=0; j<hNum; j++)
    {
        bool exist = false;
        for(int i=0; i<wNum; i++)
        {
            if( visit[wNum * j + i] )
            {
                top = j;
                xprintf("found top = %d\n", j);
                exist = true;
                break;
            }
        }
        if( exist )
            break;
    }
    int bottom;
    for(int j=hNum-1; j>-1; j--)
    {
        bool exist = false;
        for(int i=0; i<wNum; i++)
        {
            if( visit[wNum * j + i] )
            {
                bottom = j;
                xprintf("found bottom = %d\n", j);
                exist = true;
                break;
            }
        }
        if( exist )
            break;
    }
 
    xprintf("(%d, %d, %d, %d\n)\n", left, right, top, bottom);
    Rect result = RectMake(left, top, right-left+1, bottom-top+1);
 
    free(visit);
 
    return result;
}
 
int main() {
    int a[10][7] = {
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
        0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 
        0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 
        0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 
        0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 
        0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    };
    int* p = (int*)a;
    Rect rt[] = {
        click((int*)a, 10, 7, 21 / 20, 31 / 20),
        click((int*)a, 10, 7, 110 / 20, 44 / 20),
        drag((int*)a, 10, 7, 
                    RectMake(42 / 20, 24 / 20, 60 / 20, 40 / 20))
    };
    for(int i=0; i<3; i++)
    {
        Rect* r = &rt[i];
        printf("rt[%d](%d, %d, %d, %d)\n", 
            i, r->x, r->y, r->width, r->height);
    }
 
    return 0;
}
 
Colored by Color Scripter

cs

로또
1~45 숫자 중에 6개를 뽑습니다.
이번주 당첨번호 1, 2, 3, 4, 5, 6인데,
1. 몇번만에 1등 당첨번호 나오는지 구하기
2. 행운번호 7번인데, 그 사이 2등 몇번 당첨?
3. 3번을 제외한 번호 6개 중에 3등 몇번 당첨?

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

#include <iostream>
 
#if 0
#include <stdlib.h>
#include <time.h>
 
// 다르다면 count++
// 같다면 출력 count
void sort(int* n, int num)
{
    int nn = num -1;
    for(int i=0; i<nn; i++)
    {
        for(int j=1+i; j<num; j++)
        {
            if(n[i] < n[j])
            {
                int t = n[i];
                n[i] = n[j];
                n[j] = t;
            }
        }
    }
}
 
int lotto(int* answer)
{
    // answer 오름차(내림)순 정렬
    sort(answer, 6);
 
    int count = 0;
    int t[6];
    while(1)
    {
        bool equal;
        // 1~45 숫자 중에 6개를 뽑습니다.
        for(int i=0; i<6; i++)
        {
            while(1)
            {
                int r = 1 + rand()%45;
                bool exist = false;
                for(int j=0; j<i; j++)
                {
                    if( r==t[j] )
                    {
                        exist = true;
                        break;
                    }
                }
                if( exist==false )
                {
                    t[i] = r;
                    break;
                }
            }
        }
 
        // 뽑은 숫자 오른차(내림)순 정렬
        sort(t, 6);
 
        // 값을 비교 
        equal = true;
        for(int i=0; i<6; i++)
        {
            if( t[i]!=answer[i] )
            {
                equal = false;
                break;
            }
        }
 
        count++;
        if( equal )
            break;
    }
    return count;
}
#else
#include <string.h>
 
int lotto(int* answer)
{
    int count = 0, count2 = 0, count3 = 0;
    bool t[45];
    while(1)
    {
        memset(t, 0x00, 45);
        for(int i=0; i<6; i++)
        {
            while(1)
            {
                int r = rand()%45;
                if( t[r]==false )
                {
                    t[r] = true;
                    break;
                }
            }
        }
 
        int num = 0;
        for(int i=0; i<6; i++)
        {
            if( t[ answer[i]-1 ] )
                num++;
        }
 
        count++;
        if( num==6 )
            break;
        else if(num==5)
        {
            if(t[6])
                count2++;
            else if(t[2]==false)
                count3++;
 
        }
    }
    return count;
}
#endif
 
int main() {
    srand(time(NULL));
 
    int a[] = {1, 2, 3, 4, 5, 6};
    std::cout << lotto(a);
 
    return 0;
}
 
Colored by Color Scripter

cs

[게임엔진활용] 12강 콤보시스템

잼스뻔 — Mon, 8 Jun 2026 01:27:28 +0900

콤보시스템 구현 방법의 이해

- 스페이스키를 누르면 콤보1 이벤트 발생

- 콤보1 동작시 엔터키를 누르면 콤보2 이벤트 발생

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

using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
 
public class GameCombo : RenderView
{
    class Frame
    {
        public Frame(int index, float delta, Rect rtAtt)
        {
            this.index = index;
            this.delta = delta;
            this.rtAtt = rtAtt;
        }
 
        public int index;// Texture tex;
        public float delta;
        public Rect rtAtt;
    }
 
    class Combo
    {
        public Frame[] frame;
        public int frameIndex;
        public KeyControl key;
        public Combo nextCombo;
    }
 
    Combo[] combo;
 
    string[] str = {
        "주먹1-1", "주먹1-2", "주먹1-3",
        "주먹2-1", "주먹2-2"
    };
 
    bool att;
    int comboIndex, frameIndex;
    float delta;
 
    public override void load()
    {
        combo = new Combo[2];
        Combo c = new Combo();
        c.frame = new Frame[3];
        c.frame[0] = new Frame(0, 0.1f, new Rect(0, 0, 0, 0));
        c.frame[1] = new Frame(1, 0.2f, new Rect(0, 0, 0, 0));
        c.frame[2] = new Frame(2, 0.3f, new Rect(0, 0, 40, 40));
        combo[0] = c;
 
        c = new Combo();
        c.frame = new Frame[8];
        c.frame[0] = new Frame(0, 0.1f, new Rect(0, 0, 0, 0));
        c.frame[1] = new Frame(1, 0.2f, new Rect(0, 0, 0, 0));
        c.frame[2] = new Frame(2, 0.3f, new Rect(0, 0, 40, 40));
        c.frame[3] = new Frame(3, 0.1f, new Rect(0, 0, 0, 0));
        c.frame[4] = new Frame(4, 0.1f, new Rect(0, 0, 40, 40));
        c.frame[5] = new Frame(0, 0.1f, new Rect(0, 0, 0, 0));
        c.frame[6] = new Frame(1, 0.2f, new Rect(0, 0, 0, 0));
        c.frame[7] = new Frame(2, 0.3f, new Rect(0, 0, 40, 40));
        combo[1] = c;
 
        combo[0].key = Keyboard.current.spaceKey;
        combo[0].nextCombo = combo[1];
 
        combo[1].key = Keyboard.current.enterKey;
        combo[1].nextCombo = null;
 
        att = false;
        comboIndex = 0;
        frameIndex = 0;
        delta = 0.0f;
    }
 
    public override void free()
    {
    }
 
    public override void draw(float dt)
    {
        setStringSize(30);
        setStringRGBA(0.5f, 0.5f, 0.5f, 1.0f);
        for (int i = 0; i < combo.Length; i++)
        {
            drawString("콤보"+(1+i)+":", 10, 40 * i, TOP | LEFT);
            Combo c = combo[i];
            for (int j = 0; j < c.frame.Length; j++)
            {
                Frame f = c.frame[j];
                drawString(str[f.index], 110 + 130 * j, 40 * i, TOP | LEFT);
            }
 
        }
        if (att)
        {
            setStringRGBA(1.0f, 1.0f, 0.0f, 1.0f);
            int i = comboIndex;
            drawString("콤보" + (1 + i) + ":", 10, 40 * i, TOP | LEFT);
            setStringRGBA(1.0f, 1.0f, 1.0f, 1.0f);
            Combo c = combo[comboIndex];
            Frame f = c.frame[frameIndex];
            drawString(str[f.index],
                110 + 130 * frameIndex, 40 * comboIndex, TOP | LEFT);
 
            delta += dt;
            if( delta >= f.delta)
            {
                delta -= f.delta;
                frameIndex++;
                if (frameIndex == c.frame.Length)
                {
                    att = false;
                    comboIndex = 0;
                    frameIndex = 0;
                }
            }
 
            if (comboIndex == 0)
            {
                if (combo[1].key.wasPressedThisFrame)
                {
                    comboIndex++;
                }
            }
        }
        else
        {
            if (combo[0].key.wasPressedThisFrame)
            {
                att = true;
                comboIndex = 0;
                frameIndex = 0;
                delta = 0.0f;
            }
        }
 
        //if (Keyboard.current.wKey.wasPressedThisFrame)
    }
 
    public override void mouse(int stat, float x, float y)
    {
    }
}
 
Colored by Color Scripter

cs

[게임엔진활용] 11강 피하기 게임 제작

잼스뻔 — Mon, 8 Jun 2026 01:22:06 +0900

피하기 게임 제작

- 계속 피해서 적이 모이면, 적이 한곳에 모이는 현상 발생 => 해결책 과제로 제출

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

using UnityEngine;
using UnityEngine.InputSystem;
 
public class GameRog : RenderView
{
    class Enemy
    {
        public Vector2 p, v;
        public float speed;
 
        public Vector2 tP;
        public float aiDt;
    }
 
    class Hero
    {
        public Vector2 p, v;
        public float speed, stamina;
 
        public Vector2 fv;
        public float fRate, fSpeed;
    }
    Hero pHero;
 
    Enemy[] enemy;
    int enemyNum;
    float createEnemyDt;
 
    public override void load()
    {
        pHero = new Hero();
        pHero.p = new Vector2(mc.devWidth / 2, mc.devHeight / 2);
        pHero.v = new Vector2(0, 0);
        pHero.speed = 200;
        pHero.stamina = 100;
 
        enemy = new Enemy[100];
        enemyNum = 0;
        createEnemyDt = 0f;
    }
 
    public override void free()
    {
    }
 
    public override void draw(float dt)
    {
        // view
        setRGBA(0, 0, 0, 0.9f);
        fillRect(0, 0, mc.devWidth, mc.devHeight);
 
        setRGBA(1, 1, 1, 1);
        fillRect(pHero.p.x - 25, pHero.p.y - 25, 50, 50);
 
        setRGBA(1, 1, 0, 1);
        float w = 200 * pHero.stamina / 100;
        fillRect(50, 50, w, 5);
 
        setRGBA(1, 0, 0, 1);
        for (int i = 0; i < enemyNum; i++)
        {
            Enemy e = enemy[i];
            fillRect(e.p.x - 25, e.p.y - 25, 50, 50);
            // ai apply
            if (e.p != e.tP)
            {
                //e.p => e.tP; 이동
                Vector2 vector = e.tP - e.p;
                vector.Normalize();
 
                //e.p += vector * dt;
                Vector2 vt = vector * 200 * dt;
                if (e.p.x < e.tP.x)
                {
                    e.p.x += vt.x; if (e.p.x > e.tP.x) e.p.x = e.tP.x;
                }
                else if (e.p.x > e.tP.x)
                {
                    e.p.x += vt.x; if (e.p.x < e.tP.x) e.p.x = e.tP.x;
                }
                if (e.p.y < e.tP.y)
                {
                    e.p.y += vt.y; if (e.p.y > e.tP.y) e.p.y = e.tP.y;
                }
                else if (e.p.y > e.tP.y)
                {
                    e.p.y += vt.y; if (e.p.y < e.tP.y) e.p.y = e.tP.y;
                }
            }
            else
            {
                e.aiDt += dt;
                if (e.aiDt > 0.5f)
                {
                    e.aiDt = 0f;
                    e.tP = pHero.p;
                }
            }
 
            if ((pHero.p.x - e.p.x) * (pHero.p.x - e.p.x) +
                (pHero.p.y - e.p.y) * (pHero.p.y - e.p.y) < 50 * 50)
            {
                // hero dmg
                enemyNum--;
                enemy[i] = enemy[enemyNum];
                i--;
            }
        }
        setRGBA(1, 1, 1, 1);
 
        if (enemyNum < 100)
        {
            createEnemyDt += dt;
            if (createEnemyDt > 5.0f)
            {
                createEnemyDt -= 5.0f;
                Enemy e = new Enemy();
                e.p.x = getRandom() % mc.devWidth;
                e.p.y = getRandom() % mc.devHeight;
                e.tP = e.p;
 
                enemy[enemyNum] = e;
                enemyNum++;
            }
        }
 
        // ctrl
        Vector2 v = new Vector2(0, 0);
        if (Keyboard.current.wKey.isPressed) v.y = -1;
        if (Keyboard.current.sKey.isPressed) v.y = +1;
        if (Keyboard.current.aKey.isPressed) v.x = -1;
        if (Keyboard.current.dKey.isPressed) v.x = +1;
        v.Normalize();
 
        if (Keyboard.current.spaceKey.isPressed)
        {
            if (pHero.stamina > 0)
            {
                pHero.stamina -= 30 * Time.deltaTime;
                v *= 2;
            }
        }
        else
        {
            if (pHero.stamina < 100)
                pHero.stamina += 5 * Time.deltaTime;
        }
 
        pHero.p += v * pHero.speed * Time.deltaTime;
    }
 
    public override void mouse(int state, float x, float y)
    {
    }
}
Colored by Color Scripter

cs

[게임엔진활용] 10강 파티클 시스템

잼스뻔 — Mon, 8 Jun 2026 01:16:40 +0900

파티클 시스템 제작

브랜딩 방식 변경 Src : SrcAlpha Dst : One

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

using System;
using UnityEngine;
 
public class GamePS : RenderView
{
    Texture texPS;
    Vector2 position;
    float degree;
 
    class PS
    {
        public PS()
        {
            life = 0f;
        }
        public float life, _life;
        public Vector2 p, v;
        public Color cs, ce;
        public float ss, se;
    }
    PS[] _ps;// 활성화 + 비활성화 가리지 모든 입자
    PS[] ps;// 활성화 입자
    int psNum;
 
    float psDelta;
 
    public override void load()
    {
        materialIndex = 5;
 
        Texture2D tex = new Texture2D(32, 32);
        for (int i = 0; i < 32; i++)
        {
            for (int j = 0; j < 32; j++)
            {
                float d = (float)Math.Sqrt((16 - i) * (16 - i) + (16 - j) * (16 - j)) / 16;
                if (d > 1)
                    d = 1;
                float a = 1 - d;
                //a *= a;
                a = (float)Math.Sin(a * 90 * Math.PI / 180);
                tex.SetPixel(i, j, new Color(1, 1, 1, a));
            }
        }
        tex.Apply();
        texPS = tex;
 
        _ps = new PS[200];
        for (int i = 0; i < 200; i++)
            _ps[i] = new PS();
        ps = new PS[200];
        psNum = 0;
    }
 
    public override void free()
    {
    }
 
    public override void draw(float dt)
    {
        setRGBA(0, 0, 0, 0.7f);
        fillRect(0, 0, mc.devWidth, mc.devHeight);
        setRGBA(1, 1, 1, 1);
 
        materialIndex = 5;
        //drawImage(texPS, 300, 0, 0, 0, texPS.width, texPS.height, TOP | LEFT, 10, 10);
        for (int i = 0; i < psNum; i++)
        {
            PS p = ps[i];
            float r = p.life / p._life;
            p.p += p.v * dt;
            Color c = p.cs * (1 - r) + p.ce * r;
            float s = p.ss * (1 - r) + p.se * r;
            setRGBA(c.r, c.g, c.b, c.a);
            drawImage(texPS, p.p.x, p.p.y,
                0, 0, texPS.width, texPS.height, TOP | LEFT, s, s);
 
            p.life += dt;
            if (p.life > p._life)
            {
                p.life = 0;
                psNum--;
                ps[i] = ps[psNum];
                i--;
            }
        }
        setRGBA(1, 1, 1, 1);
 
        psDelta += dt;
        while (psDelta > 0.015f)
        {
            psDelta -= 0.015f;
 
            createPS((int)position.x, (int)position.y);
        }
 
        materialIndex = 0;
    }
 
    void createPS(int x, int y)
    {
        PS p = null;
        for (int i = 0; i < _ps.Length; i++)
        {
            p = _ps[i];
            if (p.life == 0)
                break;
        }
        if (p == null)
            return;
 
        p._life = 0.5f + 0.5f * (getRandom() % 100) / 99; //0.5 ~1.0f
        p.life = 0.000001f;
        p.p = new Vector2(
            (int)(x - 30 + 60f * (getRandom() % 100) / 99),
            (int)(y - 30 + 60f * (getRandom() % 100) / 99));
        p.v = new Vector2(-30 + 60 * (getRandom() % 100) / 99, -160);
        p.cs = new Color(1, 0, 0, 1);
        p.ce = new Color(1, 1, 0, 0.5f * (getRandom() % 100) / 99);
        p.ss = 2 + 1.0f * (getRandom() % 100) / 99;// 2~3
        p.se = 0.1f + 0.4f * (getRandom() % 100) / 99;// 0.1~0.5
 
        ps[psNum] = p;
        psNum++;
    }
 
    Vector2 prevPosition;
    public override void mouse(int state, float x, float y)
    {
        if (state == 0)
        {
            prevPosition = position;
            position = new Vector2(x, y);
            degree = (float)Math.Atan2(prevPosition.y - position.y, prevPosition.x - position.x);
        }
    }
}
Colored by Color Scripter

cs

[게임엔진활용] 9강 플랫포머 게임 제작

잼스뻔 — Mon, 8 Jun 2026 01:08:00 +0900

플랫포머 게임 제작

- 충돌처리

- 이중점프

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

using UnityEngine;
using UnityEngine.InputSystem;
 
public class GameCollision : RenderView
{
    struct ColObj
    {
        public Color c; // index
        public Rect rt;// image, texture
    }
    ColObj[] co;
 
    float gravity = 720 * 4;// d / s
    float jump = 0;
    int jumpNum = 0;
 
    public override void load()
    {
        Rect[] rect = new Rect[6] {
            new Rect(200, 650, 120, 40),
            new Rect(500, 550, 120, 40),
            new Rect(800, 450, 120, 40),
            new Rect(1000, 350, 120, 40),
            new Rect(700, 150, 120, 40),
            new Rect(400, 200, 120, 40),
        };
 
        co = new ColObj[8];
        // 0 ~ 5 발판
        for (int i = 0; i < 6; i++)
        {
            co[i] = new ColObj();
            co[i].c = Color.red;
            co[i].rt = rect[i];
        }
        // hero
        ColObj c = new ColObj();
        c.c = Color.black;
        c.rt = new Rect(0, mc.devHeight - 60 - 500, 60, 60);
        co[6] = c;
        // item
        c = new ColObj();
        c.c = Color.yellow;
        c.rt = new Rect(400, 200 - 60, 60, 60);
        co[7] = c;
    }
 
    public override void free()
    {
    }
 
    public override void draw(float dt)
    {
        setRGBA(0, 0, 0, 0.5f);
        fillRect(0, 0, mc.devWidth, mc.devHeight);
 
        for (int i = 0; i < 8; i++)
        {
            ColObj c = co[i];
            Rect rt = c.rt;
            setRGBA(c.c.r, c.c.g, c.c.b, c.c.a);
            fillRect(rt.x, rt.y, rt.width, rt.height);
        }
        setRGBA(1, 1, 1, 1);
 
        ref ColObj hero = ref co[6];
        if (Keyboard.current.spaceKey.wasPressedThisFrame)
        {
            if (jumpNum < 2)
            {
                jumpNum++;
                Debug.Log("jumpNum = " + jumpNum);
                jump = -700;
            }
        }
        if (Keyboard.current.aKey.isPressed)
        {
            hero.rt.x -= 300 * dt;
        }
        else if (Keyboard.current.dKey.isPressed)
        {
            hero.rt.x += 300 * dt;
        }
 
        jump += gravity * dt;
        if (jump > gravity)
            jump = gravity;
        hero.rt.y += jump * dt;
 
        float h = mc.devHeight - hero.rt.height;
 
        for (int i = 0; i < 6; i++)
        {
            ref ColObj obj = ref co[i];
            if (containRect(hero.rt, obj.rt))
            {
                if (hero.rt.y > obj.rt.y - hero.rt.height - 1)
                    h = obj.rt.y - hero.rt.height - 1;
                break;
            }
        }
        ref ColObj item = ref co[7];
        if (item.c != Color.clear &&
            containRect(hero.rt, item.rt))
        {
            item.c = Color.clear;
            Debug.Log("GameOver");
        }
 
        if (hero.rt.y > h)
        {
            hero.rt.y = h;
            jumpNum = 0;
        }
    }
 
    public override void mouse(int state, float x, float y)
    {
    }
 
}
Colored by Color Scripter

cs

[게임엔진활용] 8강 사과 게임 제작

잼스뻔 — Mon, 8 Jun 2026 00:57:24 +0900

사과 게임 제작

- 플래그값을 통한 게임씬 전환

- 버튼 제작

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

using System;
using UnityEngine;
 
public class GameScene : RenderView
{
    int gameState;// 0:title, 1:inGame
 
    public override void load()
    {
        gameState = 0;
        loadTitle();
    }
 
    public override void free()
    {
        switch (gameState)
        {
            case 0: freeTitle(); break;
            case 1: freeIngame(); break;
        }
    }
 
    public override void draw(float dt)
    {
        switch (gameState)
        {
            case 0: drawTitle(dt); break;
            case 1: drawIngame(dt); break;
        }
    }
 
    public override void mouse(int state, float x, float y)
    {
        switch (gameState)
        {
            case 0: mouseTitle(state, x, y); break;
            case 1: mouseIngame(state, x, y); break;
        }
    }
 
    // backgroud, button(play)
    Texture texLogo;
    struct Button
    {
        public Rect rt;
        public string s;
        public bool pressed;
        public Color cb;
        public Color ch;
        public Color cf;
        public float size;
    }
    Button btnPlay;
 
    void loadTitle()
    {
        texLogo = createImage("logo");
 
        Button b = new Button();
        b.rt = new Rect(10, 10, 400, 300);
        b.s = "Play";
        b.pressed = false;
        b.cb = Color.red;// 기본
        b.ch = Color.blue;// 커서
        b.cf = Color.white;
        b.size = 300;
        btnPlay = b;
 
    }
 
    void freeTitle()
    {
 
    }
 
    void drawButton(Button b)
    {
        Rect rt = b.rt;
 
        Color c = b.pressed ? b.ch : b.cb;
        setRGBA(c.r, c.g, c.b, c.a);
        fillRect(rt.x, rt.y, rt.width, rt.height);
        setRGBA(1, 1, 1, 1);
 
        setStringName("굴림");
        float stringSize = b.size;
        setStringSize(stringSize);
        Vector2 size = sizeOfString(b.s);
        if (size.x > rt.width)
            setStringSize(stringSize * rt.width / size.x);
        setStringRGBA(b.cf.r, b.cf.g, b.cf.b, b.cf.a);
        drawString(b.s, rt.x + rt.width / 2,
                                rt.y + rt.height / 2, VCENTER | HCENTER);
 
    }
 
    Image hero = null;
 
    void drawTitle(float dt)
    {
        float rx = (float)mc.devWidth / texLogo.width;
        float ry = (float)mc.devHeight / texLogo.height;
        drawImage(texLogo, 0, 0, 0, 0, texLogo.width, texLogo.height,
            TOP | LEFT, rx, ry);
 
        drawButton(btnPlay);
 
        if (hero == null)
        {
            hero = new Image(this);
 
            Texture[] texs = createImage(4, 1, "hero40");
            int[] idx = {
            1, 2, 3,    1, 2, 3,   0, 2, 3,
            1, 2, 3,    1, 2, 3,   1, 2, 3,   0, 2, 3,
            };
            for (int i = 0; i < idx.Length; i++)
                hero.add(texs[idx[i]]);
            hero._aniDt = 0.18f;
            hero.position = new Vector2(-72, -200);
            hero.startAnimation(true);
        }
 
        //for (int i = 0; i < 4; i++)
        //{
        //    drawImage(texHero[i], 100 * i, 120 * i, TOP | LEFT);
        //}
        hero.paint(dt, new Vector2(100, 120));
    }
 
    public void mouseTitle(int state, float x, float y)
    {
        switch (state)
        {
            case 0:
                if (btnPlay.pressed)
                {
                    gameState = 1;
                    freeTitle();
                    loadIngame();
                }
                break;
            case 1:
                btnPlay.pressed = containPoint(x, y, btnPlay.rt);
                break;
        }
 
    }
 
    Button[] apple;
    //int score;
    AutoNumber score;
    float playTime, _playTime;
    ProgressBar progressBar;
 
    bool gameOver;
    Button[] btnResult;
    public static Color cGreen = new Color(0.1f, 0.5f, 0.0f, 1.0f);
 
    void loadIngame()
    {
        // 60 * 15 
        float x = (mc.devWidth - 60 * 15) / 2;
        float y = (mc.devHeight - 60 * 10) / 2;
 
        apple = new Button[15 * 10];
 
        for (int i = 0; i < apple.Length; i++)
        {
            Button b = new Button();
            b.s = "" + UnityEngine.Random.Range(1, 10);
            b.rt = new Rect(x + 60 * (i % 15), y + 60 * (i / 15), 50, 50);
            b.cb = cGreen;//Color.green;
            b.ch = Color.yellow;
            b.cf = Color.white;
            b.pressed = false;
            b.size = 30;
            apple[i] = b;
        }
 
        score = new AutoNumber(0);
        _playTime = 120f;
        playTime = 120f;
 
        progressBar = new ProgressBar(new Rect(x, y - 40, 950, 30));
        progressBar.bc = Color.clear;
        progressBar.fc = Color.red;
        progressBar.lineWidth = 2f;
        progressBar.curr = 0;
        progressBar.max = 2000;
        progressBar.rv = this;
 
        gameOver = false;
        btnResult = new Button[2];
        string[] s = new string[2] { "다시시작", "나가기" };
        for (int i = 0; i < btnResult.Length; i++)
        {
            Button b = new Button();
            b.s = s[i];
            b.rt = new Rect(500 + 120 * i, 350, 100, 50);
            b.cb = Color.blue;
            b.ch = Color.black;
            b.cf = Color.white;
            b.pressed = false;
            b.size = 30;
            btnResult[i] = b;
        }
    }
 
    void freeIngame()
    {
 
    }
 
    void drawIngame(float dt)
    {
        for (int i = 0; i < apple.Length; i++)
        {
            if (apple[i].s == "0")
                continue;
            drawButton(apple[i]);
        }
 
        if (drag)
        {
            setRGBA(0, 0, 1, 0.5f);
            Rect rt = dragRect();
            fillRect(rt.x, rt.y, rt.width, rt.height);
            setRGBA(1, 1, 1, 1);
            //setLineWidth(1);
            //drawRect(rt.x, rt.y, rt.width, rt.height);
        }
 
#if false
        setRGBA(1, 0, 0, 1);
        setLineWidth(2);
        float x = (mc.devWidth - 60 * 15) / 2;
        float y = (mc.devHeight - 60 * 10) / 2;
        float w = 950;
        drawRect(x, y - 40, w, 30);
        w *= (float)score.get() / 2000;
        fillRect(x, y - 40, w, 30);
        setRGBA(1, 1, 1, 1);
#else
        //progressBar.curr = score.get();
        progressBar.curr = score;
        progressBar.paint(Time.deltaTime);
#endif
 
        setStringName("고딕체");
        setStringSize(30);
        setStringRGBA(1, 0, 0, 1);
        score.update(Time.deltaTime);
        drawString("Score : " + score.get(), mc.devWidth - 10, 10, TOP | RIGHT);
 
        setRGBA(0, 1, 0, 1);
        float h = mc.devHeight - 100;
        float dh = h * playTime / _playTime;
        fillRect(mc.devWidth - 20, 50 + h - dh, 5, dh);
        drawRect(mc.devWidth - 20, 50, 5, h);
        setRGBA(1, 1, 1, 1);
 
        playTime -= dt;
        if (playTime <= 0f)
        {
            gameOver = true;
        }
 
        if (gameOver)
        {
            setStringName("고딕체");
            setStringSize(100);
            setStringRGBA(1, 0, 0, 1);
            drawString("Score : " + score, 400, 200, TOP | LEFT);
 
            for (int i = 0; i < btnResult.Length; i++)
                drawButton(btnResult[i]);
        }
    }
 
    bool drag = false;
    float sx, sy, ex, ey;
    Rect dragRect()
    {
        float x0, x1, y0, y1;
        if (sx < ex) { x0 = sx; x1 = ex; }
        else { x0 = ex; x1 = sx; }
        if (sy < ey) { y0 = sy; y1 = ey; }
        else { y0 = ey; y1 = sy; }
        return new Rect(x0, y0, x1 - x0 - 1, y1 - y0 - 1);
    }
 
    public void mouseIngame(int state, float x, float y)
    {
        if (mouseGameOver(state, x, y))
            return;
 
        if (state == 0)
        {
            sx = ex = x;
            sy = ey = y;
            drag = true;
        }
        else if (state == 2)
        {
            drag = false;
 
            int sum = 0;
            for (int i = 0; i < apple.Length; i++)
            {
                if (apple[i].pressed)
                {
                    int n = Int32.Parse(apple[i].s);
                    sum += n;
                }
            }
            if (sum == 10)
            {
                Debug.Log("제거하자");
                for (int i = 0; i < apple.Length; i++)
                {
                    if (apple[i].pressed)
                    {
                        apple[i].s = "0";
                        score.add(100);
                    }
                }
            }
            else
            {
                for (int i = 0; i < apple.Length; i++)
                {
                    if (apple[i].pressed)
                        apple[i].pressed = false;
                }
            }
        }
        else if (drag)
        {
            ex = x;
            ey = y;
 
            Rect rt = dragRect();
 
            for (int i = 0; i < apple.Length; i++)
                apple[i].pressed = false;
            for (int i = 0; i < apple.Length; i++)
            {
                if (containRect(rt, apple[i].rt))
                {
                    if (apple[i].s != "0")
                        apple[i].pressed = true;
                }
            }
        }
    }
 
    bool mouseGameOver(int state, float x, float y)
    {
        if (gameOver == false)
            return false;
 
        switch (state)
        {
            case 0:
                for (int i = 0; i < btnResult.Length; i++)
                {
                    if (btnResult[i].pressed)
                    {
                        if (i == 0)
                        {
                            // 다시시작
                            for (int j = 0; j < apple.Length; j++)
                            {
                                apple[j].s = "" + UnityEngine.Random.Range(1, 10);
                                apple[j].pressed = false;
                            }
                            score.set(0);
                            playTime = _playTime;
                            gameOver = false;
 
                        }
                        else
                        {
                            // 나가기
                            gameState = 0;
                            freeIngame();
                            loadTitle();
                        }
                        break;
                    }
                }
                break;
            case 1:
                for (int i = 0; i < btnResult.Length; i++)
                    btnResult[i].pressed = containPoint(x, y, btnResult[i].rt);
                break;
        }
 
        return true;
    }
}
 
Colored by Color Scripter

cs

- AutoNumber : 값이 단계를 거쳐 변화도록 구현

- 프로그래스바

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

using UnityEngine;
 
public class AutoNumber
{
    int number;
    int numberS, numberE;
    float delta, _delta;
 
    public AutoNumber(int v, float duration = 0.3f)
    {
        number = v;
        _delta = duration;
        delta = duration;
    }
 
    // 객체가 같은지, 값이 같은지 구분
    public override bool Equals(object obj)
    {
        return base.Equals(obj);
    }
    public override int GetHashCode()
    {
        return base.GetHashCode();
    }
    public static bool operator ==(AutoNumber a, AutoNumber b)
    {
        return a.get() == b.get();
    }
    public static bool operator !=(AutoNumber a, AutoNumber b)
    {
        return a.get() != b.get();
    }
 
    // int n = an;
    public static implicit operator int(AutoNumber p)
    {
        return p.get();
    }
    // AutoNumber an = (AutoNumber)5;
    public static explicit operator AutoNumber(int n)
    {
        return new AutoNumber(n);
    }
 
    public static AutoNumber operator +(AutoNumber a, AutoNumber b)
    {
        AutoNumber an = new AutoNumber(a.number);
        an.add(b.number);
        return an;
    }
    public static AutoNumber operator +(AutoNumber a, int b)
    {
        AutoNumber an = new AutoNumber(a.number);
        an.add(b);
        return an;
    }
    public static AutoNumber operator -(AutoNumber a, AutoNumber b)
    {
        AutoNumber an = new AutoNumber(a.number);
        an.add(-b.number);
        return an;
    }
    public static AutoNumber operator -(AutoNumber a, int b)
    {
        AutoNumber an = new AutoNumber(a.number);
        an.add(-b);
        return an;
    }
 
    // ++, --
    public static AutoNumber operator ++(AutoNumber a)
    {
        a.add(1);
        return a;
    }
    public static AutoNumber operator --(AutoNumber a)
    {
        a.add(-1);
        return a;
    }
 
    public void set(int v)
    {
        number = v;
    }
 
    public void add(int v)
    {
        //number += v;
        if (delta < _delta)
        {
            numberS = get();
            numberE = numberE + v;
        }
        else
        {
            numberS = number;
            numberE = number + v;
        }
        delta = 0.0f;
    }
 
    public int get()
    {
        if( delta < _delta )
        {
            float r = delta / _delta;
            return (int)(numberS * (1.0f - r) + numberE * r);
        }
        return number;
    }
 
    public void update(float dt)
    {
        if( delta < _delta)
        {
            delta += dt;
            if( delta >= _delta )
            {
                delta = _delta;
                number = numberE;
            }
        }
    }
}
 
Colored by Color Scripter

cs

[게임엔진활용] 7강 게임 시스템 구성

잼스뻔 — Mon, 8 Jun 2026 00:45:58 +0900

기존 방식 (Hierachy > 우클릭 Create Empty > RenderView 명명 > Add Component : RenderView.cs) 에서,

RenderView클래스를 상속받은 새로운 클래스에서 load / free / draw / mouse로 직관적으로 코드를 작성할 수 있도록 수정.

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

public class RenderView : MonoBehaviour
{
    public virtual void load() { }
    public virtual void free() { }
    public virtual void draw(float dt) { }
    public virtual void mouse(int state, float x, float y) { }
 
    public MainCamera mc;
 
    void Start()
    {
        mc = FindFirstObjectByType<MainCamera>();
        ...
 
        load();
        MainCamera.methodMouse = mouse;        
    }
 
    ~RenderView()
    {
        free();
    }
 
    void OnGUI()
    {
        if (Event.current.type != EventType.Repaint)
            return;
 
        ...
 
        GL.Clear(true, true, Color.clear);
        draw(Time.deltaTime);// do something ...
 
        ...
    }
}
 
public class MainCamera : MonoBehaviour
{
    void Start()
    {
        ...
        setGame("GameScene");// GameScene / GameCollision / GamePS / GameCombo
    }
    static GameObject rv = null;
    public static void setGame(string nameScene)
    {
        GameObject go = new GameObject(nameScene);
        System.Type t = System.Type.GetType(nameScene);
        go.AddComponent(t);
 
        if (rv != null)
        {
            GameObject.Destroy(rv);
            Resources.UnloadUnusedAssets();
        }
        rv = go;
    }
    public delegate void MethodMouse(int state, float x, float y);
    public static MethodMouse methodMouse = null;
}
 
 
Colored by Color Scripter

cs

메인 카메라에서 setGame("GameScene"); 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

public class GameScene : RenderView
{
    public override void load()
    {
        // 리소스 로딩
    }
 
    public override void free()
    {
        // 리소스 해제
    }
 
    public override void draw(float dt)
    {
        // 그리기
        // 키보드 제어
    }
 
    public override void mouse(int state, float x, float y)
    {
        // 마우스 제
    }
}
 
Colored by Color Scripter

cs

매일매일 열심히 게임 개발하고 있습니다