🪨 'The Rolling Stone' Game (2025.04 ~ 2025.06)

C++, OpenGL, Bullet Physics, Skeletal Animation based 3D physics simulation

• Optimized matrix frame updates for better FPS
• Implemented Physics Debug Drawer
• Natural animation synchronization with character-object interactions

// ======== MAIN RENDERING LOOP ========
while (!glfwWindowShouldClose(window))
{
    // 1) Calculate FPS
    float currentFrame = static_cast(glfwGetTime());
    if (!VSYNC && currentFrame - lastFrame <= frameTime) continue;
    deltaTime = currentFrame - lastFrame;
    lastFrame = currentFrame;

    // 2) Update view-projection matrices
    glm::mat4 projection = glm::perspective(glm::radians(camera.Zoom),
        (float)WINDOW_WIDTH / (float)WINDOW_HEIGHT, 0.1f, frustum_far);
    glm::mat4 view = camera.GetViewMatrix();

    // 3) Start physical simulation
    dynamicsWorld->stepSimulation(deltaTime);

    // 4) Update player's position using bullet library
    btTransform trans;
    characterBody->getMotionState()->getWorldTransform(trans);
    btVector3 btPos = trans.getOrigin();
    character->position = glm::vec3(
        btPos.getX(),
        btPos.getY() - gTotalColliderHeight * 0.5f + 0.05f,
        btPos.getZ());

    // 5) Processing user's input
    processInput(window, defaultAnimations, runAnimations);

    // 6) Check collision
    // ... // Collision with ground, Detect slope, Collision with other object

    // 7) Update animation matrices
    glm::mat4 model = glm::mat4(1.0f);
    animator.updateAnimation(deltaTime);
    updateNodeTransformations(root, model);
    auto transforms = animator.getFinalBoneMatrices();

    // 8) Root rendering
    renderNode(root);

    // 9) Line Debug & GUI
    // ... // ImGui Panel

    // 10) Terminate the frame
    glfwSwapBuffers(window);
    glfwPollEvents();
}              
            

🛠️ Role: Physics system design, Animation optimization, Logic improvements

🔗 Github Source: 'The Rolling Stone Game' Repository

▶️ Watch Demo (YouTube)

🧭 Talk & Go: 3D Campus Guide System in Sangmyung University (2025.03 ~ 2025.09)

Unity 3D, Firebase, OpenAI API powered 3D campus navigation system

📸 Demo Highlights

(1) Sign-up

(2) Login

(3) Path Finder(Go)

(3-1) Path Visualizer(Go)

(4) Chatbot Q & A(Talk)

📁 System Development Overview

🔍 View Details

Component	Language	Tech Stack	Internal Features	External Integration
Unity 3D	C#	Probuilder NavMesh	UI structure (Pathfinder, Chatbot, Campus map) Three Pathfinding Methods: NavMesh & Dijkstra-based	Firebase: Authentication Django: Communicate with JSON via UnityWebRequest class React: Rendering embedded WebGL layer
Django Rest Framework (Backend)	Python	Django Rest API	Search internal database (campus information) Calling OpenAI API for using GPT-3.5 Turbo model/li> Refining GPT-answers based system prompts Return JSON-formatted responses	Receive questions from the client and return responses Implement functionality for storing, deleting, and loading Q & A
React with Node.js (Frontend)	JavaScript	React Node.js	User interface layout of web	Render Unity WebGL layer onto React page
Firebase		Web App Authentication Firestore Database	Authentication: Sign-up and Login functionality Stores Chatbot Q & A data in Firestore Database for each user account (UID)	Storing: Storing Chatbot Q & A data to Firebase Database, passed by each user account (Django) Loading: Transfer user UID and Q&A data from Firebase to Django

// ================= PATH1 (Original NavMesh) =================
public void FindPath1()
{
    string startName = startInputNode.text.Trim();
    string endName = endInputNode.text.Trim();

    Vector3 start = GetNodePosition(startName);
    Vector3 end = GetNodePosition(endName);

    // Check if any cache saved
    if (cachedNavMeshPaths[0] != null)
    {
        pathLineDrawer1.DrawPath(cachedNavMeshPaths[0]);
        UIDebugTextAnimator.Instance.debugTextMsg.text =
            "저장된 NavMesh 경로 불러오기 완료";
        UIDebugTextAnimator.Instance.AnimateAll();
        StartCoroutine(TurnOnVisualizerBtn((int)Pathfinders.NavMesh1 - 1));
        return;
    }

    path1 = new NavMeshPath();
    NavMesh.CalculatePath(start, end, NavMesh.AllAreas, path1);
    pathLineDrawer1.DrawPath(path1);
    cachedNavMeshPaths[0] = path1;
}
              

// ================= PATH2 (NavMesh with Virtual Wall) =================                
private void CreateVirtualWall(DangerCornerPair pair)
{
    if (currentWall != null) Destroy(currentWall);

    Vector3 a = pair.pointA.position;
    Vector3 b = pair.pointB.position;
    Vector3 center = (a + b) / 2f;

    GameObject wall = GameObject.CreatePrimitive(PrimitiveType.Cube);
    wall.name = "DangerWall";
    wall.transform.position = center + Vector3.up * 1f;
    wall.transform.rotation = Quaternion.LookRotation(b - a);
    wall.transform.localScale = new Vector3(0.3f, 2f, Vector3.Distance(a, b));

    if (dangerWallMaterial != null)
        wall.GetComponent<Renderer>().material = dangerWallMaterial;

    var obstacle = wall.AddComponent<NavMeshObstacle>();
    obstacle.carving = true;
    obstacle.shape = NavMeshObstacleShape.Box;
    obstacle.size = new Vector3(0.3f, 2f, 1f);
    obstacle.center = Vector3.zero;
    obstacle.carveOnlyStationary = true;

    currentWall = wall;
}
              

// ================= PATH3 (Dijkstra)=================
public List<Vector3> Dijkstra(string startNode, string endNode)
{
    Dictionary<string, float> distances = new();
    Dictionary<string, string> previous = new();
    List<string> unvisited = new(nodes.Keys);

    foreach (var node in nodes.Keys)
        distances[node] = float.MaxValue;
    distances[startNode] = 0;

    while (unvisited.Count > 0)
    {
        // 1. Select the node that has min distance far
        string current = unvisited.OrderBy(n => distances[n]).First();
        unvisited.Remove(current);

        // 2. Finish if the node ends
        if (current == endNode)
            break;

        // 3. Search an adjacent node
        foreach (var neighbor in nodes[current].neighbors)
        {
            float alt = distances[current] + Vector3.Distance(
                nodes[current].position, nodes[neighbor].position);

            if (alt < distances[neighbor])
            {
                distances[neighbor] = alt;
                previous[neighbor] = current;
            }
        }
    }

    // 4️. Backtrack shortest path
    List<Vector3> path = new();
    string nodeTrace = endNode;
    while (previous.ContainsKey(nodeTrace))
    {
        path.Insert(0, nodes[nodeTrace].position);
        nodeTrace = previous[nodeTrace];
    }
    path.Insert(0, nodes[startNode].position);

    // 5. Visualization
    pathLineDrawer3.DrawPath(path);
    UIDebugTextAnimator.Instance.debugTextMsg.text = "Dijkstra Path Complete";
    UIDebugTextAnimator.Instance.AnimateAll();

    return path;
}
            

🛠️ Role

• Unity: Developed user interface and core logic
• Firebase: Implemented sign-up and login features; saved and retrieved Chatbot Q & A logs
• Full-stack Web: Integrated Django with Firebase and connected Django with Unity

✨ Special Notes

• Unity WebGL: As the Firebase SDK is not supported in Unity WebGL, Django was implemented as an intermediary to enable Firebase ↔ Unity integration through REST APIs

🔗 Github Source: University Campus Map Navigation System Repository

📷 Real-time People Detection on NPU-embedded(Neural Processing Unit) Edge Camera (2024.07 ~ 2024.09)

Deployed the YOLOv5s model on an NPU-embedded edge device through model quantization and porting

• Quantization: PyTorch(.pt) → ONNX(.onnx) → Quantization(Kneron Toolchain WebGUI) → NEF(.nef) final conversion as binary file
• Implemented real-time people detection using the quantized YOLOv5s model
• Verified the efficient operation of the vision model under limited computational resources

# ======== PyTorch → ONNX CONVERSION ========
import torch
import torch.onnx
import os

# 1) Set file paths for the .pt model and ONNX output
pt_file_path = '/path/to/your/best.pt'         # Path to the trained PyTorch model
onnx_file_path = '/path/to/save/best.onnx'     # Path to export the ONNX model

# 2) Load the model (change 'cpu' to 'cuda' if using GPU)
model = torch.load(pt_file_path, map_location=torch.device('cpu'))
model.eval()  # Switch model to evaluation mode

# 3) Create dummy input (adjust shape according to the model input)
dummy_input = torch.randn(1, 3, 224, 224)  # Example: batch=1, channels=3, height=224, width=224

# 4) Create directory if it does not exist
os.makedirs(os.path.dirname(onnx_file_path), exist_ok=True)

# 5) Export the model to ONNX format
torch.onnx.export(model, dummy_input, onnx_file_path, opset_version=11)

print(f"✅ ONNX file successfully generated: {onnx_file_path}")
              

# ======== ONNX OPTIMIZATION ========
import ktc                      # Kneron Toolchain
import onnx
import torch.onnx

# 1) Load the existing ONNX model
exp = onnx.load('YYMMDD_output.onnx')

# 2) Optimize the PyTorch → ONNX conversion flow
result = ktc.onnx_optimizer.torch_exported_onnx_flow(exp)  # Warning messages can be ignored

# 3) Perform ONNX → ONNX optimization (remove unnecessary operations)
opt = ktc.onnx_optimizer.onnx2onnx_flow(result, eliminate_tail=True)

# 4) Save the optimized ONNX model
onnx.save(opt, 'YYMMDD_final_output.onnx')

print("✅ ONNX optimization completed: YYMMDD_final_output.onnx")
              

🛠️ Role: Model Quantization, Porting, Real-time Inference Validation

🌐 Environment: PyTorch 1.7.1+cu110 · TorchVision 0.8.2 · ONNX 1.13.0 · Docker Desktop 4.30.0 · Kneron Toolchain WebGUI · KL630 NPU · PuTTY 0.83 · VLC 3.0.20

✨ Special Notes: This project was conducted based on internal company documentation. For security reasons, the ID and personal information have been blurred or anonymized

⚽ #1 Ball Collector Game (2025.02.02 ~ 2025.02.12)

Unity based 3D platformer mini-game inspired by GoldMetal tutorials

• Applied 3D physics and jump boost logic based on collectible triggers
• Used Sprite-based 2D user interface with stage status & retry conditions
• Designed level transitions across three different map scenes

🎮 Game Overview

• A game where the player rolls a ball across narrow and precarious platforms to collect all items (using the W, A, S, D keys)
• Blue items are standard collectibles, while yellow items grant a one-time double jump ability
• If all items are not collected, the game will restart even after reaching the final destination!

🛠️ Role: Solo development

🔗 Github Source: Ball Collector Game Repository (Github)

📝 Notion Source: Ball Collector Game Note (Notion)

🎯 #2 Get Coin Game (2025.02.16 ~ 2025.03.15)

Unity based small-scale game project

• 2D jump logic based on item triggers with physical colliders applied
• User interface implemented using 2D sprites
• Stage-based game structure utilizing three distinct scene layouts

🎮 Game Overview

• A game where players collect different types of coins while avoiding enemies (using arrow keys)
• There are four types of potions, each providing the following effects
  - Red Potion: Restores one unit of health
  - Green Potion: Grants a one-time double jump
  - Blue Potion: Temporarily increases jump power
  - Yellow Potion: Grants temporary invisibility
• There are two types of portals, each providing the following effects
  - Red Portal: Instantly teleports the player to a linked portal
  - Black Portal: Moves the player to the next stage
• Escape the wide stage within the given time!

🛠️ Role: Solo development

🔗 Github Source: Get Coin Game Repository (Github)

📝 Notion Source: Get Coin Game Note (Notion)

🪨 'The Rolling Stone' 게임 (2025.04 ~ 2025.06)

C++, OpenGL, Bullet Physics, Skeletal Animation 기반 3D 물리 시뮬레이션 게임

• 본 행렬 프레임 최적화로 FPS 성능 향상
• 물리 디버깅 함수 구현
• 캐릭터-오브젝트 상호작용에 따른 자연스러운 애니메이션 동기화

// ======== 메인 렌더링 루프 ========
while (!glfwWindowShouldClose(window))
{
    // 1) 초당 프레임 계산
    float currentFrame = static_cast(glfwGetTime());
    if (!VSYNC && currentFrame - lastFrame <= frameTime) continue;
    deltaTime = currentFrame - lastFrame;
    lastFrame = currentFrame;

    // 2) 카메라 및 투영행렬 갱신
    glm::mat4 projection = glm::perspective(glm::radians(camera.Zoom),
        (float)WINDOW_WIDTH / (float)WINDOW_HEIGHT, 0.1f, frustum_far);
    glm::mat4 view = camera.GetViewMatrix();

    // 3) 물리 시뮬레이션 진행
    dynamicsWorld->stepSimulation(deltaTime);

    // 4) 플레이어 위치 갱신
    btTransform trans;
    characterBody->getMotionState()->getWorldTransform(trans);
    btVector3 btPos = trans.getOrigin();
    character->position = glm::vec3(
        btPos.getX(),
        btPos.getY() - gTotalColliderHeight * 0.5f + 0.05f,
        btPos.getZ());

    // 5) 사용자 입력 처리
    processInput(window, defaultAnimations, runAnimations);

    // 6) 충돌 상태 확인
    // ... // 지면 충돌, 슬로프 감지, 오브젝트 접촉 여부 등을 계산함

    // 7) 애니메이션 갱신
    glm::mat4 model = glm::mat4(1.0f);
    animator.updateAnimation(deltaTime);
    updateNodeTransformations(root, model);
    auto transforms = animator.getFinalBoneMatrices();

    // 8) 루트 렌더링
    renderNode(root);

    // 9) Line Debug & GUI
    // ... // ImGui 패널

    // 10) 프레임 마무리
    glfwSwapBuffers(window);
    glfwPollEvents();
}              
            

🛠️ 담당 역할: 물리 시스템 설계, 애니메이션 최적화, 로직 개선

🔗 깃허브 링크: 'The Rolling Stone' 게임 저장소

▶️ 시연 영상 보기 (유튜브)

🧭 톡앤고(Talk & Go): 3차원 상명대학교 캠퍼스 가이드 시스템 (2025.03 ~ 2025.09)

Unity 3D, Firebase, OpenAI API를 활용한 3차원 캠퍼스 내비게이션 시스템

📸 데모 하이라이트

(1) 회원가입

(2) 로그인

(3) 길찾기(Go)

(3-1) 경로 시각화(Go)

(4) 챗봇 질의응답(Talk)

📁 시스템 개발 개요

🔍 자세히 보기

구성 요소	언어	기술 스택	내부 구현 기능	외부와의 연동
Unity 3D	C#	Probuilder NavMesh	사용자 인터페이스 구성 (길찾기, 챗봇, 캠퍼스맵) NavMesh & Dijkstra 알고리즘 기반 총 3개의 길찾기 기능	Firebase: 보안 인증 Django: UnityWebRequest 클래스를 통한 JSON 통신 React: WebGL layer 추가 렌더링
Django Rest Framework (Backend)	Python	Django Rest API	학교 정보가 저장된 데이터베이스 탐색 GPT-3.5 Turbo 모델 사용을 위한 OpenAI API 호출 시스템 프롬프트 기반 응답 정제 JSON 형식의 응답 생성	클라이언트로부터 전달된 질문 수신 및 응답 반환 질의응답 저장, 삭제, 불러오기 기능 구현 (Firebase Database)
React with Node.js (Frontend)	JavaScript	React Node.js	웹 사용자 인터페이스 구성	Unity WebGL layer를 React 위에 렌더링
Firebase		Web App Authentication Firestore Database	보안: 회원가입 및 로그인 기능 사용자별 Chatbot 질의응답 데이터를 Firestore DB에 저장	저장: 전달받은 사용자 고유 식별자(UID)를 통해 사용자별 Chatbot 질의응답을 Firebase DB에 저장 (Django) 불러오기: 사용자 고유 식별자(UID) 및 질의응답 데이터 → Django로 전달 (Firebase)

🔧 기술 세부 사항

• Path Finder: 산악 지형 기반의 경로 탐색 시스템(두 개의 NavMesh & 사설 Dijkstra 알고리즘)
• Path Visualizer: 사설 클래스 "LineDebugger" 를 활용한 경로 시각화 시스템
• 첫 NavMesh 탐색 후: 다음 NavMesh에서 특정 코너 오브젝트 간 통과 여부 판별 및 가상 벽 생성, 우회 경로 도출
• ChatGPT 기반 대화형 질의응답 시스템 설계
• Firebase를 활용한 회원가입 및 로그인 기능 구현, 챗봇 질의응답 로그 저장 및 불러오기 기능 구현

// ================= PATH1 (기본 NavMesh) =================
public void FindPath1()
{
    string startName = startInputNode.text.Trim();
    string endName = endInputNode.text.Trim();

    Vector3 start = GetNodePosition(startName);
    Vector3 end = GetNodePosition(endName);

    // Cache 저장 여부 확인
    if (cachedNavMeshPaths[0] != null)
    {
        pathLineDrawer1.DrawPath(cachedNavMeshPaths[0]);
        UIDebugTextAnimator.Instance.debugTextMsg.text =
            "저장된 NavMesh 경로 불러오기 완료";
        UIDebugTextAnimator.Instance.AnimateAll();
        StartCoroutine(TurnOnVisualizerBtn((int)Pathfinders.NavMesh1 - 1));
        return;
    }

    path1 = new NavMeshPath();
    NavMesh.CalculatePath(start, end, NavMesh.AllAreas, path1);
    pathLineDrawer1.DrawPath(path1);
    cachedNavMeshPaths[0] = path1;
}
              

// ================= PATH2 (가상 벽이 추가된 NavMesh) =================                
private void CreateVirtualWall(DangerCornerPair pair)
{
    if (currentWall != null) Destroy(currentWall);

    Vector3 a = pair.pointA.position;
    Vector3 b = pair.pointB.position;
    Vector3 center = (a + b) / 2f;

    GameObject wall = GameObject.CreatePrimitive(PrimitiveType.Cube);
    wall.name = "DangerWall";
    wall.transform.position = center + Vector3.up * 1f;
    wall.transform.rotation = Quaternion.LookRotation(b - a);
    wall.transform.localScale = new Vector3(0.3f, 2f, Vector3.Distance(a, b));

    if (dangerWallMaterial != null)
        wall.GetComponent<Renderer>().material = dangerWallMaterial;

    var obstacle = wall.AddComponent<NavMeshObstacle>();
    obstacle.carving = true;
    obstacle.shape = NavMeshObstacleShape.Box;
    obstacle.size = new Vector3(0.3f, 2f, 1f);
    obstacle.center = Vector3.zero;
    obstacle.carveOnlyStationary = true;

    currentWall = wall;
}
              

// ================= PATH3 (Dijkstra)=================
public List<Vector3> Dijkstra(string startNode, string endNode)
{
    Dictionary<string, float> distances = new();
    Dictionary<string, string> previous = new();
    List<string> unvisited = new(nodes.Keys);

    foreach (var node in nodes.Keys)
        distances[node] = float.MaxValue;
    distances[startNode] = 0;

    while (unvisited.Count > 0)
    {
        // 1. 현재까지 거리 중 최소 노드 선택
        string current = unvisited.OrderBy(n => distances[n]).First();
        unvisited.Remove(current);

        // 2. 목적지 도달 시 종료
        if (current == endNode)
            break;

        // 3. 인접 노드 탐색
        foreach (var neighbor in nodes[current].neighbors)
        {
            float alt = distances[current] + Vector3.Distance(
                nodes[current].position, nodes[neighbor].position);

            if (alt < distances[neighbor])
            {
                distances[neighbor] = alt;
                previous[neighbor] = current;
            }
        }
    }

    // 4. 최단 경로 역추적
    List<Vector3> path = new();
    string nodeTrace = endNode;
    while (previous.ContainsKey(nodeTrace))
    {
        path.Insert(0, nodes[nodeTrace].position);
        nodeTrace = previous[nodeTrace];
    }
    path.Insert(0, nodes[startNode].position);

    // 5. 시각화
    pathLineDrawer3.DrawPath(path);
    UIDebugTextAnimator.Instance.debugTextMsg.text = "Dijkstra Path Complete";
    UIDebugTextAnimator.Instance.AnimateAll();

    return path;
}
            

🛠️ 담당 역할

• Unity: 사용자 인터페이스 개발, 로직 담당
• Firebase: 회원가입 및 로그인 기능 구현, 챗봇 질의응답 로그 저장 및 불러오기
• Full-stack Web: Django와 Firebase 간 연동, Django와 Unity 간 연동 진행

✨ 특이사항

• Unity WebGL: Firebase SDK를 지원받지 못 해 연동을 위해 Django를 중간 매개체로 하여 Rest API를 통해 Firebase ↔ Unity 연동 진행

🔗 깃허브 링크: 대학교 캠퍼스 맵 3차원 내비게이션 시스템 저장소

📷 NPU(신경 처리 장치) 내장형 에지 카메라 기반의 실시간 사람 탐지 (2024.07 ~ 2024.09)

NPU(Neural Processing Unit) 칩이 탑재된 에지 카메라에 YOLOv5s 모델 경량화 및 포팅 수행

• 경량화 과정: PyTorch(.pt) → ONNX(.onnx) → Kneron Toolchain WebGUI를 통한 경량화 → 이진 파일로서 NEF(.nef) 최종 변환
• 경량화된 YOLOv5s 모델을 카메라 보드에 포팅하여 실시간 사람 감지 구현
• 제한된 연산 환경에서 비전 모델의 효율적 동작 검증

# ======== PyTorch → ONNX 변환 ========
import torch
import torch.onnx
import os

# 1) .pt 모델 파일 경로 및 ONNX 저장 경로 설정
pt_file_path = '/path/to/your/best.pt'         # 학습된 PyTorch 모델 경로
onnx_file_path = '/path/to/save/best.onnx'     # 내보낼 ONNX 모델 경로

# 2) 모델 로드 ('cpu' 대신 'cuda' 사용 시 GPU 환경 적용 가능)
model = torch.load(pt_file_path, map_location=torch.device('cpu'))
model.eval()  # 모델을 평가 모드로 전환

# 3) 더미 입력 데이터 생성 (모델 입력 형태에 맞게 조정 필요)
dummy_input = torch.randn(1, 3, 224, 224)  # 예시: 배치=1, 채널=3, 높이=224, 너비=224

# 4) 출력 폴더가 존재하지 않으면 자동 생성
os.makedirs(os.path.dirname(onnx_file_path), exist_ok=True)

# 5) 모델을 ONNX 형식으로 내보내기
torch.onnx.export(model, dummy_input, onnx_file_path, opset_version=11)

print(f"✅ ONNX 파일이 성공적으로 생성되었습니다: {onnx_file_path}")
              

# ======== ONNX 최적화 ========
import ktc                      # Kneron Toolchain 모듈
import onnx
import torch.onnx

# 1) 기존 ONNX 모델 불러오기
exp = onnx.load('YYMMDD_output.onnx')

# 2) PyTorch → ONNX 변환 과정 최적화
result = ktc.onnx_optimizer.torch_exported_onnx_flow(exp)  # Warning 메시지는 무시 가능

# 3) ONNX → ONNX 최적화 수행 (불필요한 연산 제거)
opt = ktc.onnx_optimizer.onnx2onnx_flow(result, eliminate_tail=True)

# 4) 최적화된 ONNX 모델 저장
onnx.save(opt, 'YYMMDD_final_output.onnx')

print("✅ ONNX 최적화 완료: YYMMDD_final_output.onnx")
              

🛠️ 담당 역할: 모델 경량화, 포팅, 실시간 인퍼런스 검증

🌐 개발 환경: PyTorch 1.7.1+cu110 · TorchVision 0.8.2 · ONNX 1.13.0 · Docker Desktop 4.30.0 · Kneron Toolchain WebGUI · KL630 NPU · PuTTY 0.83 · VLC 3.0.20

✨ 특이사항: 회사 내부 매뉴얼을 기반으로 진행된 프로젝트로, 보안상의 이유로 아이디 및 인물 정보를 모두 모자이크 처리

⚽ #1 3D 공 굴리기 수집 게임 (2025.02.02 ~ 2025.02.12)

Unity 3D 기반 GoldMetal 튜토리얼을 바탕으로 제작한 3D 미니게임

• 아이템 트리거 기반 3차원 점프 로직 및 물리 시스템 적용
• 2차원 스프라이트를 활용한 사용자 인터페이스 구현
• 총 3개의 서로 다른 씬 구조를 활용한 단계별 게임 구성

🎮 게임 요약

• 조작키와 함께 공을 굴리며 아슬아슬한 발판 위를 이동하여 모든 아이템을 수집하는 게임 (조작키: W, A, S, D)
• 파란 아이템은 일반 수집용이며, 노란 아이템은 일회성 2단 점프 기능을 제공
• 모든 아이템을 수집하지 못 하면 최종 지점에 도달하더라도 게임 재시작

🛠️ 담당 역할: 단독 개발

🔗 깃허브 링크: 3D 공 굴리기 수집 게임 저장소 (깃허브)

📝 노션 링크: 3D 공 굴리기 수집 게임 노트 (노션)

🎯 #2 2D 코인 먹기 게임 (2025.02.16 ~ 2025.03.15)

Unity 2D 기반 GoldMetal 튜토리얼을 바탕으로 제작한 소규모 2D 게임

• 아이템 트리거 기반 2D 점프 로직과 물리적 콜라이더 적용
• 2차원 스프라이트를 활용하여 사용자 인터페이스 구현
• 총 3개의 서로 다른 장면 구조를 활용하여 단계별 게임 구성

🎮 게임 요약

• 방향키 조작과 함께 적을 피해 서로 다른 종류의 코인을 수집하는 게임
• 포션은 총 4종류로 구성되며, 각각 다음과 같은 효과 제공
  - 빨간 포션: 체력 1칸 회복
  - 초록 포션: 일회성 2단 점프
  - 파란 포션: 일정 시간 점프력 증가
  - 노란 포션: 일정 시간 투명 효과
• 포탈은 총 2종류로 구성되며, 각각 다음과 같은 효과 제공
  - 빨간 포탈: 연결된 다른 포탈의 위치로 순간이동
  - 검은 포탈: 다음 스테이지로 이동
• 주어진 시간 내에 넓은 스테이지를 탈출하세요!

🛠️ 담당 역할: 단독 개발

🔗 깃허브 링크: 2차원 코인 먹기 게임 저장소 (깃허브)

📝 노션 링크: 2차원 코인 먹기 게임 노트 (노션)