웹게임?

sourceoftax — Wed, 11 Feb 2026 17:56:46 +0900

http://youtube.com/watch?v=iYbAqAclhuk&feature=youtu.be

플레이 영상

학교 동아리 초보 코딩 대회 냈던 거

컨셉

초기 기획안은 다음과 같습니다

초기 화면

집 배경
돌아다니는 마릴리
휴대폰 손에 쥐고 있음(이게 메뉴 화면) -> 휴대폰 앱을 클릭하면 이벤트로 넘어갈 수 있음

이벤트 1(산책)

공통: 화면을 걸어가며 랜덤 이벤트 조우 형식. 마릴리의 총 체력 5. 다니며 다른 포켓몬들을 조우 가능. 조우시 '선공/지켜보기/도망' 중 선택 가능. 호전적인 포켓몬을 만났을 시: '선공'시 해당 포켓몬이 가진 나무열매or조미료 습득 가능. '지켜보기' 시 50% 확률로 공격받음(마릴리의 체력-1), 50% 확률로 아무 일도 일어나지 않음. '도망' 선택시 25% 확률로 공격받음(마릴리의 체력 -1) 중립적인 포켓몬을 만났을 시: '선공'시 해당 포켓몬이 가진 나무열매or조미료 습득 가능. '지켜보기' 시 50% 확률로 공격받음(마릴리의 체력-1), 50% 확률로 온순한 포켓몬이 다가와 나무열매를 건네줌. '도망' 선택시 아무 일도 일어나지 않음 온순한 포켓몬을 만났을 시: '선공'시 해당 포켓몬이 가진 나무열매 습득 가능, '죄책감이 든다...'라는 메시지 나옴. '지켜보기' 시 50% 확률로 온순한 포켓몬이 다가와 나무열매를 건네줌, 50% 확률로 아무 일도 일어나지 않음. '도망' 선택시 아무 일도 일어나지 않음

마릴리의 체력이 0이 되면 강제 귀가. 아래의 이벤트가 나오면(조우 확률 약 10%) 산책 성공으로 처리함. 이후 초기 화면으로 돌아감

1-1. 숲

대량의 나무열매를 획득 가능

1-2. 강

대량의 조미료 획득 가능. 마릴리의 기분이 좋아짐

이벤트 2(요리)

보유한 나무열매와 조미료를 선택해 진입 가능. 소지한 나무열매 or 조미료가 하나도 없다면 진입 불가 2-1. 불 지피기: 클릭 or 스페이스바 연타를 통해 불이 꺼지지 않게 유지해야 함
완성된 요리를 마릴리가 먹는 CG. 이후 초기 화면으로 돌아감
여기에 나무열매와 조미료 조합에 따라 마릴리의 선호가 달라지는 변동성 넣어도 좋을듯?

이벤트 3(목욕)

마릴리 일러스트에 스펀지(마우스 커서)를 대고 클릭하면 거품 묻히기 가능 -> 이후 거품이 충분히(시스템 최대 거품 기준 70% 이상) 묻었다면 샤워기 아이콘 등장 -> 샤워기로 거품을 씻어내면 이벤트 완료. 초기 화면으로 돌아감

해당 로직들을 구현하기 위해 코드를 크게 네 가지로 분류해 작성하였습니다.

Python산책: 턴 수에 따라 이벤트 확률을 증가시키고, 포켓몬 조우 시 성격과 사용자의 선택에 따라 피해·보상 결과를 계산합니다.목욕: 진행도를 받아 샤워기 해금 여부를 판단하는 로직을 담당합니다.
요리: 사용자가 투입한 재료 조합을 레시피 테이블과 비교해 결과와 기분 변화를 결정합니다.
게임의 상태를 저장하고, 프론트엔드에서 필요한 정보를 API로 제공하는 백엔드 역할입니다. 각 모듈에서 해당 코드가 맡은 역할은 다음과 같습니다
HTML
게임 화면의 구조를 정의하는 프론트엔드 레이아웃입니다. 집·산책·요리·목욕을 각각 하나의 section으로 구성해 한 페이지 안에 배치하고, JavaScript가 필요한 화면만 전환하도록 설계했습니다. HUD, 대사창, 선택 버튼, 진행 바 등 주요 UI 요소를 미리 배치하며, 이미지 리소스를 불러오는 경로도 함께 정의합니다.
Javascript산책: 일정 시간마다 조우 요청 + 선택 UI 표시 및 결과 메시지·상태 갱신을 처리합니다.요리: 재료 사용량을 서버에 전달하고, 결과에 맞는 반응 연출을 출력합니다.
목욕: 포인터 이동에 따라 진행도를 증가시키고, 70% 이상일 경우 샤워 모드로 전환합니다.
서버 API를 호출해 상태를 받아오고, 이를 즉시 화면에 반영하는 역할을 합니다. 화면 전환 관리와 대사 출력 로직을 담당하며, 각 기능별 동작 흐름을 제어합니다.
CSS
전체를 풀스크린으로 고정하고 각 장면들을 absolute로 겹쳐 올린 다음 필요한 장면들만 보이게 합니다. HUD는 반투명 패널을 사용해 다른 화면을 완전히 가리지 않게 만들었습니다. 또한 캐릭터의 흔들림 애니메이션, 목욕 커서 변경 등 시각적인 효과를 담당하는 파트입니다.

후기

코드 전반을 작성할 때 동일한 포켓몬 소재+웹게임으로 제작된 POKEROGUE의 코드(https://github.com/pagefaultgames/pokerogue, 공식 깃허브)를 참조했습니다. 이미지는 공식 이미지/

javascripts 코드가 상당히 긴데, 만드는 중간에 개별 기능들을 모듈화하는게 훨씬 편했을 거라는 생각이 들어 아쉬움이 남습니다.

더 넣고 싶은 기능이 많았지만 자꾸만 오류가 나 삭제하게 된 기능들이 다수 있었습니다. 알고리즘에 대한 공부와 게임 엔진을 사용하는 법을 공부해서 다음에는 더 퀄리티 높은 게임을 만들어보고 싶습니다

코드

1. py

from flask import Flask, render_template, jsonify, request, session
import random

app = Flask(__name__)
app.secret_key = "dev-secret-change-me"

POKEMON_DB = [
    {"id": "mankey", "name": "망키", "temper": "aggressive", "loot": {"berries": (0, 1), "spices": (1, 2)}, "weight": 12},
    {"id": "ekans",  "name": "아보", "temper": "aggressive", "loot": {"berries": (0, 1), "spices": (1, 1)}, "weight": 10},
    {"id": "zubat",  "name": "주뱃", "temper": "aggressive", "loot": {"berries": (0, 1), "spices": (1, 1)}, "weight": 8},

    {"id": "pidgey", "name": "구구", "temper": "neutral", "loot": {"berries": (1, 2), "spices": (0, 1)}, "weight": 14},
    {"id": "oddish", "name": "뚜벅쵸", "temper": "neutral", "loot": {"berries": (1, 1), "spices": (0, 2)}, "weight": 10},
    {"id": "sandshrew", "name": "모래두지", "temper": "neutral", "loot": {"berries": (1, 2), "spices": (0, 1)}, "weight": 8},

    {"id": "togepi", "name": "토게피", "temper": "gentle", "loot": {"berries": (1, 2)}, "weight": 10},
    {"id": "chansey","name": "럭키", "temper": "gentle", "loot": {"berries": (2, 3)}, "weight": 6},
    {"id": "eevee",  "name": "이브이", "temper": "gentle", "loot": {"berries": (1, 3)}, "weight": 9},
]

RECIPE_TABLE = {
    (1, 0): {"name": "달콤한 수프", "pref": +1, "message": "평범한 조합이다. 마릴리가 즐거워하며 먹었다."},
    (0, 1): {"name": "짠맛 수프", "pref": 0,  "message": "짠 맛이 느껴진다... 마릴리의 취향은 아닌 것 같다."},
    (1, 1): {"name": "이상적인 수프", "pref": +2, "message": "성공적이다! 마릴리가 매우 기쁜 것 같다."},
    (2, 1): {"name": "진한 수프", "pref": +3, "message": "진한 맛이 느껴진다. 마릴리는 기쁘게 먹었다."},
}

DEFAULT_STATE = {
    "hp": 5,
    "berries": 0,
    "spices": 0,
    "mood": "idle",
    "status": "home",
    "walk_turn": 0
}

def clamp_int(x, lo, hi):
    try:
        x = int(x)
    except:
        x = lo
    return max(lo, min(hi, x))

def pick_pokemon():
    weights = [p["weight"] for p in POKEMON_DB]
    return random.choices(POKEMON_DB, weights=weights, k=1)[0]

def roll_loot(pokemon):
    loot = {}
    for k, (a, b) in pokemon["loot"].items():
        loot[k] = random.randint(a, b)
    return loot

def get_state():
    if "state" not in session:
        session["state"] = DEFAULT_STATE.copy()
    return session["state"]

def save_state(state):
    session["state"] = state

@app.route('/')
def home():
    return render_template('index.html')

@app.get('/api/status')
def get_status():
    return jsonify(get_state())

@app.post('/api/reset')
def api_reset():
    session["state"] = DEFAULT_STATE.copy()
    return jsonify(session["state"])

@app.post('/api/walk/encounter')
def walk_event():
    state = get_state()

    if state["hp"] <= 0:
        return jsonify({"type": "forced_home", "reason": "hp_zero", "state": state})

    state["walk_turn"] = int(state.get("walk_turn", 0)) + 1
    turn = state["walk_turn"]

    chance = 0.0
    if turn >= 4:
        chance = 0.10 * (turn - 3)    
        chance = min(chance, 1.0)

    if random.random() < chance:
        gained = random.randint(2,4)
        state["spices"] += gained
        msg = f"강을 발견했다! 조미료를 {gained}만큼 얻었다."

        state["status"] = "home"
        save_state(state)
        return jsonify({"type": "success_spot", "spot": "river", "message": msg, "state": state})

    pokemon = pick_pokemon()
    save_state(state)  
    return jsonify({
        "type": "encounter",
        "pokemon": {"id": pokemon["id"], "name": pokemon["name"], "temper": pokemon["temper"]},
        "state": state
    })

@app.post("/api/walk/start")
def walk_start():
    state = get_state()
    state["walk_turn"] = 0
    save_state(state)
    return jsonify({"ok": True, "state": state})

@app.post("/api/walk/resolve")
def walk_resolve():
    state = get_state()
    if state["hp"] <= 0:
        state["status"] = "home"
        save_state(state)
        return jsonify({"ended": True, "message": "집에 갈 시간이다", "state": state})

    payload = request.get_json(force=True)
    pokemon_id = payload.get("pokemon_id")
    action = payload.get("action")

    pokemon = next((p for p in POKEMON_DB if p["id"] == pokemon_id), None)
    if not pokemon:
        return jsonify({"error": "invalid_pokemon"}), 400

    temper = pokemon["temper"]
    hp_delta = 0
    loot = {"berries": 0, "spices": 0}
    message = ""

    def take_damage():
        nonlocal hp_delta
        hp_delta -= 1

    def gain_loot():
        rolled = roll_loot(pokemon)
        for k, v in rolled.items():
            loot[k] += v

    if action == "attack":
        gain_loot()
        message = f"{pokemon['name']}에게서 재료를 얻었다!" if temper != "gentle" else f"{pokemon['name']}에게서 재료를 얻었다. 왜인지 죄책감이 든다..."
    elif action == "watch":
        if temper in ("aggressive", "neutral"):
            if random.random() < 0.5:
                take_damage()
                message = f"지켜보다가 {pokemon['name']}에게 공격받았다!"
            else:
                if temper == "neutral":
                    gain_loot()
                    message = f"{pokemon['name']}이(가) 다가와 재료를 건네줬다!"
                else:
                    message = "아무 일도 일어나지 않았다."
        else:
            if random.random() < 0.5:
                gain_loot()
                message = f"{pokemon['name']}이(가) 다가와 나무열매를 건네줬다!"
            else:
                message = "아무 일도 일어나지 않았다."
    elif action == "run":
        if temper == "aggressive":
            if random.random() < 0.25:
                take_damage()
                message = f"도망치다 {pokemon['name']}에게 공격받았다!"
            else:
                message = "무사히 도망쳤다."
        else:
            message = "도망쳤다. 아무 일도 일어나지 않았다."
    else:
        return jsonify({"error": "invalid_action"}), 400

    state["hp"] = max(0, state["hp"] + hp_delta)
    state["berries"] += loot["berries"]
    state["spices"] += loot["spices"]

    ended = False
    if state["hp"] <= 0:
        ended = True
        state["status"] = "home"
        message += " 마릴리가 많이 피곤한 것 같다..."

    save_state(state)
    return jsonify({"ended": ended, "hp_delta": hp_delta, "loot": loot, "message": message, "state": state})

@app.get("/api/cook/can_enter")
def cook_can_enter():
    state = get_state()
    can = (state["berries"] > 0 or state["spices"] > 0)
    return jsonify({"can_enter": can, "state": state})

@app.post("/api/cook/finish")
def cook_finish():
    state = get_state()
    payload = request.get_json(force=True)

    berries_used = clamp_int(payload.get("berries_used", 0), 0, state["berries"])
    spices_used = clamp_int(payload.get("spices_used", 0), 0, state["spices"])

    if berries_used == 0 and spices_used == 0:
        return jsonify({"ok": False, "message": "재료가 없습니다.", "state": state})

    state["berries"] -= berries_used
    state["spices"] -= spices_used

    recipe = RECIPE_TABLE.get((berries_used, spices_used)) or {"name": "이상한 요리", "pref": 0, "message": "마릴리가 애매한 표정으로 먹었다."}

    if recipe["pref"] >= 2:
        state["mood"] = "happy"
    elif recipe["pref"] <= -1:
        state["mood"] = "sad"
    else:
        state["mood"] = "idle"

    save_state(state)
    return jsonify({"ok": True, "recipe": recipe, "used": {"berries": berries_used, "spices": spices_used}, "state": state})

@app.post("/api/bath/progress")
def bath_progress():
    state = get_state()
    payload = request.get_json(force=True)
    percent = int(payload.get("percent", 0))
    percent = max(0, min(100, percent))
    return jsonify({"percent": percent, "unlock_shower": percent >= 70, "state": state})

if __name__ == "__main__":
    app.run(debug=True)

2. html

<!DOCTYPE html>
<html lang="ko">
<head>
  <meta charset="UTF-8">
  <title>project 1</title>
  <meta name="viewport" content="width=device-width, initial-scale=1, user-scalable=no" />
  <link rel="stylesheet" href="{{ url_for('static', filename='css/style.css') }}">
</head>
<body>
  <audio id="bgmPlayer" loop>
    <source id="bgmSource" src="" type="audio/mpeg">
  </audio>

  <audio id="marillSound">
    <source src="{{ url_for('static', filename='sounds/marill_cry.mp3') }}" type="audio/mpeg">
  </audio>

  <div id="hud">
    <div id="hud-hp"></div>
    <div id="hud-items">
      <span id="hud-berries">  0</span>
      <span id="hud-spices">  0</span>
    </div>
  </div>

<div id="dialogue-layer" class="ui-layer" style="display:none;">
  <div id="dialogue-box">
    <div id="dialogue-name" style="display:none;"></div>
    <div id="dialogue-text"></div>
    <div id="dialogue-progress" class="dialogue-progress" style="display:none;">
      <div id="dialogue-progress-fill"></div>
    </div>
    <div id="dialogue-hint">▶</div>
  </div>
</div>


  <div id="game-viewport">
    <section id="screen-home" class="screen" style="display:block;">
      <img src="{{ url_for('static', filename='images/bg_home.png') }}" class="bg">

      <div id="wandering-marill-container">
        <img src="{{ url_for('static', filename='images/marill_idle.png') }}" id="wandering-marill" class="character">
      </div>

      <div id="smartphone-container">
        <img src="{{ url_for('static', filename='images/ui/smartphone_frame.png') }}" id="phone-frame-img">
        <div class="app-screen-overlay">
          <div class="app-grid">
            <button class="app-btn" data-event="walk">
              <img src="{{ url_for('static', filename='images/ui/icon_walk.png') }}" alt="산책">
              <span>산책</span>
            </button>
            <button class="app-btn" data-event="cook">
              <img src="{{ url_for('static', filename='images/ui/icon_cook.png') }}" alt="요리">
              <span>요리</span>
            </button>
            <button class="app-btn" data-event="bath">
              <img src="{{ url_for('static', filename='images/ui/icon_bath.png') }}" alt="목욕">
              <span>목욕</span>
            </button>
          </div>
        </div>
      </div>
    </section>

    <section id="screen-walk" class="screen" style="display:none;">
      <img src="{{ url_for('static', filename='images/bg_forest.png') }}" id="walk-bg" class="bg">
      <img id = "walk-marill" src="{{ url_for('static', filename='images/marill_back.png') }}" class="character walk-ani">
      <img id="enemy-img" class="enemy-img" style="display:none;" />

      <div id="walk-info" class="toast">걷는 중…</div>
      <button id = "walk-exit" class="walk-exit">나가기</button>

      <div id="encounter-ui" class="modal" style="display:none;">
        <p id="encounter-text"></p>
        <div class="row">
          <button id="btn-attack">선공</button>
          <button id="btn-watch">지켜보기</button>
          <button id="btn-run">도망</button>
        </div>
      </div>
    </section>


<section id="screen-cook" class="screen" style="display:none;">
  <img src="{{ url_for('static', filename='images/bg_home.png') }}" class="bg">

  <div id="cook-select" class="panel">
    <h3>요리</h3>

    <div class="row" style="align-items:center;">
      <label>  <input id="cook-berries" type="number" min="0" value="1" /></label>
      <label>  <input id="cook-spices" type="number" min="0" value="0" /></label>
    </div>

    <div class="row">
      <button id="cook-confirm">시작</button>
      <button id="cook-recipe">레시피 확인</button>
      <button id="cook-exit">나가기</button>
    </div>

    <div class="hint" id="cook-select-hint">재료를 고르고 '확인'을 눌러야 요리를 시작합니다</div>
  </div>

  <div id="cook-play" class="cook-stage" style="display:none;">
    <img id="cook-stage-img" class="cook-stage-img"
         src="{{ url_for('static', filename='images/cooking.png') }}" alt="cooking">

    <div id="gauge" class="cook-gauge">
      <div id="gauge-fill"></div>
    </div>

    <div id="cook-phase" class="cook-phase">불 지피기</div>
    <div class="hint" id="cook-hint">화면을 누르면 게이지가 올라갑니다</div>

    <div class="row cook-bottom">
      <button id="cook-play-exit">나가기</button>
    </div>
  </div>

  <div id="cook-result" class="cook-stage" style="display:none;">
    <img id="cook-finish-img" class="cook-stage-img"
         src="{{ url_for('static', filename='images/cooking_finish.png') }}" alt="finish">

    <img id="cook-reaction-img" class="cook-reaction-img" style="display:none;" alt="reaction">

    <div id="cook-result-text" class="cook-result-text"></div>

    <div class="row cook-bottom">
      <button id="cook-result-exit">나가기</button>
    </div>
  </div>
</section>




  <section id="screen-bath" class="screen" style="display:none;">
  <img src="{{ url_for('static', filename='images/bg_bathroom.png') }}" class="bg">

  <div id="bubble-layer">
    <div class="bubble"></div>
    <div class="bubble"></div>
    <div class="bubble"></div>
    <div class="bubble"></div>
    <div class="bubble"></div>
    <div class="bubble"></div>
  </div>

  <div class="bath-center">
    <img id="bath-marill" class="bath-marill"
         src="{{ url_for('static', filename='images/marill_idle.png') }}">

    <div id="bath-progress" class="bath-progress">
      <div id="bath-fill"></div>
    </div>
  </div>

  <div class="panel bath-panel">
    <h3>목욕</h3>
    <div class="hint">화면을 문지르면 마릴리를 씻길 수 있습니다</div>

    <button id="shower-icon" style="display:none;">샤워기</button>
    <div class="row">
      <button id="bath-exit">나가기</button>
    </div>
  </div>
</section>


  <script src="{{ url_for('static', filename='js/main.js') }}"></script>
</body>
</html>

3. js

async function apiGet(url) {
  const r = await fetch(url, { credentials: "same-origin" });
  return r.json();
}
async function apiPost(url, bodyObj = {}) {
  const r = await fetch(url, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    credentials: "same-origin",
    body: JSON.stringify(bodyObj)
  });
  return r.json();
}

function renderHUD(state) {
  const hpWrap = document.getElementById("hud-hp");
  if (!hpWrap) return;

  const hp = Number(state?.hp ?? 0);
  hpWrap.innerHTML = "";
  for (let i = 0; i < 5; i++) {
    const span = document.createElement("span");
    span.className = "heart" + (i < hp ? " on" : " off");
    span.textContent = "♥";
    hpWrap.appendChild(span);
  }

  const b = document.getElementById("hud-berries");
  const s = document.getElementById("hud-spices");
  if (b) b.textContent = `  ${Number(state?.berries ?? 0)}`;
  if (s) s.textContent = `  ${Number(state?.spices ?? 0)}`;
}

let currentScreen = "home";

function showScreen(name) {
  document.querySelectorAll(".screen").forEach(s => (s.style.display = "none"));
  const target = document.getElementById(`screen-${name}`);
  if (target) target.style.display = "block";
  currentScreen = name;

  if (name === "home") startWanderingMarill();
  else stopWandering();
}


let wanderTimer = null;
const wander = { x: 50, y: 60, vx: 0, vy: 0 };

function clamp(v, lo, hi) {
  return Math.max(lo, Math.min(hi, v));
}

function startWanderingMarill() {
  const c = document.getElementById("wandering-marill-container");
  const img = document.getElementById("wandering-marill");
  if (!c || !img) return;

  stopWandering();

  wander.x = parseFloat(c.style.left || "50");
  wander.y = parseFloat(c.style.top || "60");
  wander.vx = 0;
  wander.vy = 0;

  wanderTimer = setInterval(() => stepWander(c, img), 120);
}

function stopWandering() {
  if (wanderTimer) clearInterval(wanderTimer);
  wanderTimer = null;
}

function stepWander(container, img) {
  const minX = 10, maxX = 80;
  const minY = 40, maxY = 75;

  const ax = (Math.random() - 0.5) * 0.67;
  const ay = (Math.random() - 0.5) * 0.5;

  wander.vx = (wander.vx + ax) * 0.82;
  wander.vy = (wander.vy + ay) * 0.82;

  wander.vx = clamp(wander.vx, -0.9, 0.9);
  wander.vy = clamp(wander.vy, -0.6, 0.6);

  const prevX = wander.x;
  wander.x += wander.vx;
  wander.y += wander.vy;

  if (wander.x < minX) { wander.x = minX; wander.vx *= -0.8; }
  if (wander.x > maxX) { wander.x = maxX; wander.vx *= -0.8; }
  if (wander.y < minY) { wander.y = minY; wander.vy *= -0.8; }
  if (wander.y > maxY) { wander.y = maxY; wander.vy *= -0.8; }

  if (wander.x < prevX) img.classList.add("facing-left");
  else img.classList.remove("facing-left");

  container.style.left = `${wander.x}%`;
  container.style.top = `${wander.y}%`;
}

const dialogue = {
  currentFull: "",
  active: false,
  queue: [],
  typing: false,
  typeTimer: null,
  resolveWait: null,

  elLayer: null,
  elBox: null,
  elName: null,
  elText: null,
  elHint: null,

  init() {
    this.elLayer = document.getElementById("dialogue-layer");
    this.elBox   = document.getElementById("dialogue-box");
    this.elName  = document.getElementById("dialogue-name");
    this.elText  = document.getElementById("dialogue-text");
    this.elHint  = document.getElementById("dialogue-hint");

    if (!this.elLayer || !this.elBox || !this.elText || !this.elHint || !this.elName) {
      console.warn("Dialogue DOM missing");
      return;
    }

    this.elLayer.style.display = "none";
    this.elLayer.style.pointerEvents = "none";
    this.elBox.addEventListener("click", () => this.advance());

    window.addEventListener("keydown", (e) => {
      if (!this.active) return;
      if (e.key === " " || e.key === "Enter") {
        e.preventDefault();
        this.advance();
      }
    });
  },

  async show(lines, opts = {}) {
    if (!this.elLayer) this.init();
    if (!this.elLayer) return; 

    const arr = Array.isArray(lines) ? lines : [{ text: String(lines) }];
    for (const it of arr) {
      if (typeof it === "string") this.queue.push({ text: it, name: "" });
      else this.queue.push({ text: String(it.text ?? ""), name: it.name ? String(it.name) : "" });
    }

    if (this.active) return;

    this.active = true;
    this.elLayer.style.display = "block";
    this.elLayer.style.pointerEvents = "none";
    this.elBox.style.pointerEvents = "auto";

    while (this.queue.length > 0) {
      const item = this.queue.shift();
      await this.playOne(item, opts);
    }

    this.elLayer.style.display = "none";
    this.elLayer.style.pointerEvents = "none";
    this.active = false;
  },

  playOne(item, opts) {
    const speed = Number.isFinite(opts.speed) ? opts.speed : 22;

    if (item.name) {
      this.elName.style.display = "block";
      this.elName.textContent = item.name;
    } else {
      this.elName.style.display = "none";
      this.elName.textContent = "";
    }

    this.elText.textContent = "";
    this.elHint.style.display = "none";
    this.typing = true;

    const full = item.text;
    this.currentFull = full;
    let i = 0;

    clearInterval(this.typeTimer);
    this.typeTimer = setInterval(() => {
      i++;
      this.elText.textContent = full.slice(0, i);
      if (i >= full.length) {
        clearInterval(this.typeTimer);
        this.typeTimer = null;
        this.typing = false;
        this.elHint.style.display = "block";
      }
    }, speed);

    return new Promise((resolve) => {
      this.resolveWait = resolve;
    });
  },

  advance() {
    if (!this.active) return;

    if (this.typing) {
      clearInterval(this.typeTimer);
      this.typeTimer = null;
      this.typing = false;
      this.elText.textContent = this.currentFull;
      this.elHint.style.display = "block";
      return;
    }

    if (this.resolveWait && !this.typing) {
      const r = this.resolveWait;
      this.resolveWait = null;
      r();
    }
  }
};

//산책 모듈


const walk = {
  timer: null,
  pending: null,
  exitBound: false,
  _busy: false,

  async start() {
    this.stopTimerOnly();
    this.pending = null;

    const bg = document.getElementById("walk-bg");
    const mar = document.getElementById("walk-marill");
    if (bg) bg.src = "/static/images/bg_forest.png";
    if (mar) {
      mar.src = "/static/images/marill_back.png";
      mar.classList.add("walk-ani");
      mar.style.left = "";
      mar.style.bottom = "";
      mar.style.transform = "";
    }

    const enc = document.getElementById("encounter-ui");
    const enemy = document.getElementById("enemy-img");
    if (enc) enc.style.display = "none";
    if (enemy) enemy.style.display = "none";

    if (!this.exitBound) {
      this.exitBound = true;
      const exitBtn = document.getElementById("walk-exit");
      if (exitBtn) {
        exitBtn.addEventListener("click", () => {
          this.stop();
          showScreen("home");
        });
      }
    }

    this.timer = setInterval(async () => {
      if (this._busy) return;
      this._busy = true;

      let res = null;
      try {
        res = await apiPost("/api/walk/encounter", {});
      } catch (e) {
        console.error("walk encounter failed", e);
      } finally {
        this._busy = false;
      }
      if (!res) return;

      if (res.type === "success_spot" && res.spot === "river") {
        if (bg) bg.src = "/static/images/bg_river.png";
        if (mar) {
          mar.src = "/static/images/marill_happy.png";
          mar.classList.remove("walk-ani");
          mar.style.left = "50%";
          mar.style.bottom = "22%";
          mar.style.transform = "translateX(-50%)";
        }

        renderHUD(res.state);
        await dialogue.show(res.message || "");

        this.stop();
        showScreen("home");
        return;
      }

      if (res.type === "encounter") {
        this.pending = {
          pokemon_id: res.pokemon.id,
          pokemon_name: res.pokemon.name,
          temper: res.pokemon.temper
        };
        this.showEncounter(res.pokemon);
        this.stopTimerOnly();
      }
    }, 3000);
  },

  stopTimerOnly() {
    if (this.timer) clearInterval(this.timer);
    this.timer = null;
  },

  stop() {
    this.stopTimerOnly();
    this.pending = null;
    const enc = document.getElementById("encounter-ui");
    const enemy = document.getElementById("enemy-img");
    if (enc) enc.style.display = "none";
    if (enemy) enemy.style.display = "none";
  },

  showEncounter(p) {
    const map = { aggressive: "호전적인", neutral: "중립적인", gentle: "온순한" };
    const t = document.getElementById("encounter-text");
    if (t) t.textContent = `${map[p.temper]} ${p.name}이(가) 나타났다!`;

    const enemy = document.getElementById("enemy-img");
    if (enemy) {
      enemy.src = `/static/images/walk/p_${p.id}.png`;
      enemy.style.display = "block";
    }

    const enc = document.getElementById("encounter-ui");
    if (enc) enc.style.display = "block";
  },

  async choose(action) {
    if (!this.pending) return;

    let res;
    try {
      res = await apiPost("/api/walk/resolve", {
        pokemon_id: this.pending.pokemon_id,
        action
      });
    } catch (e) {
      console.error("walk resolve failed", e);
      this.pending = null;
      this.start();
      return;
    }

    if (res?.error) {
      console.warn(res);
      this.pending = null;
      this.start();
      return;
    }

    const enc = document.getElementById("encounter-ui");
    const enemy = document.getElementById("enemy-img");
    if (enc) enc.style.display = "none";
    if (enemy) enemy.style.display = "none";

    renderHUD(res.state);
    await dialogue.show(res.message || "");

    this.pending = null;

    if (res.ended) {
      this.stop();
      showScreen("home");
      return;
    }

    this.start();
  }
};

//요리 모듈

const cook = {
  gauge: 0,
  onTap: null,
  _finishing: false,
  berriesUsed: 0,
  spicesUsed: 0,
  els: null,

  bindEls() {
    if (this.els) return;
    this.els = {
      select: document.getElementById("cook-select"),
      play: document.getElementById("cook-play"),
      result: document.getElementById("cook-result"),

      bInp: document.getElementById("cook-berries"),
      sInp: document.getElementById("cook-spices"),

      btnConfirm: document.getElementById("cook-confirm"),
      btnRecipe: document.getElementById("cook-recipe"),
      btnExitSelect: document.getElementById("cook-exit"),

      stageImg: document.getElementById("cook-stage-img"),
      phase: document.getElementById("cook-phase"),
      hint: document.getElementById("cook-hint"),
      gaugeFill: document.getElementById("gauge-fill"),

      btnExitPlay: document.getElementById("cook-play-exit"),

      finishImg: document.getElementById("cook-finish-img"),
      reactImg: document.getElementById("cook-reaction-img"),
      resultText: document.getElementById("cook-result-text"),
      btnResultExit: document.getElementById("cook-result-exit"),
    };

    const must = [
      "select","play","result",
      "bInp","sInp",
      "btnConfirm","btnRecipe","btnExitSelect",
      "stageImg","phase","hint","gaugeFill",
      "btnExitPlay",
      "finishImg","reactImg","resultText","btnResultExit"
    ];
    for (const k of must) {
      if (!this.els[k]) throw new Error("COOK DOM missing: " + k);
    }

    this.els.btnConfirm.addEventListener("click", () => this.confirmEnter());
    this.els.btnRecipe.addEventListener("click", () => this.showRecipe());

    this.els.btnExitSelect.addEventListener("click", () => this.exitToHome());
    this.els.btnExitPlay.addEventListener("click", () => this.exitToHome());
    this.els.btnResultExit.addEventListener("click", () => this.exitToHome());
  },

  showOnly(which) {
    this.els.select.style.display = (which === "select") ? "block" : "none";
    this.els.play.style.display   = (which === "play")   ? "flex"  : "none";
    this.els.result.style.display = (which === "result") ? "flex"  : "none";
  },

  async start() {
    this.bindEls();
    this.stop();

    const can = await apiGet("/api/cook/can_enter");
    renderHUD(can.state);

    if (!can.can_enter) {
      await dialogue.show("재료가 하나도 없으면 요리할 수 없습니다.");
      showScreen("home");
      return;
    }

    this.els.bInp.max = String(can.state.berries);
    this.els.sInp.max = String(can.state.spices);

    this.els.bInp.value = can.state.berries > 0 ? "1" : "0";
    this.els.sInp.value = "0";

    this.showOnly("select");
  },

  async showRecipe() {
    const text =
`레시피
 1  0 : 달콤한 수프
 0  1 : 짠맛 수프
 1  1 : 이상적인 수프
 2  1 : 진한 수프
그 외 조합 : 이상한 요리`;
    await dialogue.show(text);
  },

  confirmEnter() {
    const b = parseInt(this.els.bInp.value || "0", 10) || 0;
    const s = parseInt(this.els.sInp.value || "0", 10) || 0;

    if (b === 0 && s === 0) {
      alert("재료를 1개 이상 선택해야 합니다.");
      return;
    }

    this.berriesUsed = b;
    this.spicesUsed = s;

    this.enterCooking();
  },

  enterCooking() {
    this.stop();
    this.gauge = 0;
    this.renderGauge();

    this.els.stageImg.src = "/static/images/cooking.png";
    this.els.phase.textContent = "요리 중";
    this.els.hint.textContent = "화면을 누르면 게이지가 올라갑니다";

    this.showOnly("play");

    const screen = document.getElementById("screen-cook");
    this.onTap = () => {
      this.gauge = Math.min(100, this.gauge + 4.5);
      this.renderGauge();
      if (this.gauge >= 100) this.finish();
    };
    screen.addEventListener("pointerdown", this.onTap);
  },

  renderGauge() {
    if (this.els?.gaugeFill) this.els.gaugeFill.style.width = `${this.gauge}%`;
  },

  stop() {
    const screen = document.getElementById("screen-cook");
    if (this.onTap) screen.removeEventListener("pointerdown", this.onTap);
    this.onTap = null;
    this._finishing = false;
  },

  reactionAssetByPref(pref) {
    if (pref >= 2) return "/static/images/cooking_react_happy.png";
    if (pref <= -1) return "/static/images/cooking_react_sad.png";
    return "/static/images/cooking_react_idle.png";
  },

  async finish() {
    if (this._finishing) return;
    this._finishing = true;

    this.stop();

    const res = await apiPost("/api/cook/finish", {
      berries_used: this.berriesUsed,
      spices_used: this.spicesUsed
    });

    this._finishing = false;

    if (!res.ok) {
      alert(res.message);
      showScreen("home");
      return;
    }

    renderHUD(res.state);

    this.showOnly("result");
    this.els.finishImg.src = "/static/images/cooking_finish.png";

    const pref = Number(res.recipe?.pref ?? 0);
    const reactSrc = this.reactionAssetByPref(pref);

    this.els.reactImg.style.display = "block";
    this.els.reactImg.src = reactSrc;
    this.els.reactImg.onerror = () => {
      this.els.reactImg.style.display = "none";
    };

    this.els.resultText.textContent = "";
    this.els.resultText.style.display = "none";

    await dialogue.show([
      { text: `${res.recipe.name}를 만들었다.` },
      { text: res.recipe.message }
    ]);
  },

  exitToHome() {
    this.stop();
    showScreen("home");
  }
};

// 목욕 모듈


const bath = {
  percent: 0,
  unlocked: false,
  showerMode: false,
  washProgress: 0,
  onMove: null,
  smileTimer: null,


  dProg: null,
  dFill: null,

  isNearEl(e, el, threshold = 90) {
    const r = el.getBoundingClientRect();
    const cx = r.left + r.width / 2;
    const cy = r.top + r.height / 2;
    return Math.hypot(e.clientX - cx, e.clientY - cy) <= threshold;
  },

  placeBubblesNearMarill() {
    const marill = document.getElementById("bath-marill");
    const layer = document.getElementById("bubble-layer");
    if (!marill || !layer) return;

    const mr = marill.getBoundingClientRect();
    const lr = layer.getBoundingClientRect();
    const cx = (mr.left + mr.right) / 2 - lr.left;
    const cy = (mr.top + mr.bottom) / 2 - lr.top;

    const bubbles = Array.from(layer.querySelectorAll(".bubble"));
    bubbles.forEach((b) => {
      const dx = (Math.random() - 0.5) * 260;
      const dy = (Math.random() - 0.5) * 180;
      b.style.left = `${cx + dx}px`;
      b.style.top = `${cy + dy}px`;
    });
  },

  start() {
    this.stop();

    this.dProg = document.getElementById("dialogue-progress");
    this.dFill = document.getElementById("dialogue-progress-fill");
    if (this.dProg) this.dProg.style.display = "block";
    if (this.dFill) this.dFill.style.width = "0%";

    this.percent = 0;
    this.unlocked = false;
    this.showerMode = false;
    this.washProgress = 0;

    const layer = document.getElementById("bubble-layer");
    if (layer) layer.style.display = "none";

    const bathFill = document.getElementById("bath-fill");
    if (bathFill) bathFill.style.width = "0%";

    const screen = document.getElementById("screen-bath");
    const showerBtn = document.getElementById("shower-icon");
    const marill = document.getElementById("bath-marill");
    if (!screen || !showerBtn || !marill) return;

    showerBtn.style.display = "none";

    screen.classList.add("sponge-cursor");
    screen.classList.remove("shower-cursor");

    const idleSrc = "/static/images/marill_idle.png";
    const smileSrc = "/static/images/marill_smile.png";
    this.smileTimer = setInterval(() => {
      marill.src = smileSrc;
      setTimeout(() => { marill.src = idleSrc; }, 700);
    }, 4500);

    let last = 0;

    this.onMove = async (e) => {
      const now = performance.now();
      if (now - last < 30) return;
      last = now;

      if (!this.showerMode) {
        if (!this.isNearEl(e, marill, 130)) return;

        this.percent = Math.min(100, this.percent + 1);

        if (bathFill) bathFill.style.width = `${this.percent}%`;

        if (this.dFill) this.dFill.style.width = `${this.percent}%`;

        if (layer && this.percent > 0) {
          layer.style.display = "block";
          this.placeBubblesNearMarill();
        }

        const res = await apiPost("/api/bath/progress", { percent: this.percent });
        if (res.unlock_shower && !this.unlocked) {
          this.unlocked = true;
          showerBtn.style.display = "inline-block";
          
        }
      } else {
        await this.washMove(e);
      }
    };

    screen.addEventListener("pointermove", this.onMove);
    showerBtn.onclick = () => this.enableShowerMode();
  },

  enableShowerMode() {
    const screen = document.getElementById("screen-bath");
    const layer = document.getElementById("bubble-layer");
    if (layer) layer.style.display = "block";

    this.showerMode = true;
    this.washProgress = 0;

    if (this.dFill) this.dFill.style.width = "0%";

    if (screen) {
      screen.classList.remove("sponge-cursor");
      screen.classList.add("shower-cursor");
    }
  },

  async washMove(e) {
    const bubbles = Array.from(document.querySelectorAll("#bubble-layer .bubble"));
    if (bubbles.length === 0) return;

    const threshold = 110;
    let near = false;
    for (const b of bubbles) {
      if (this.isNearEl(e, b, threshold)) { near = true; break; }
    }
    if (!near) return;

    this.washProgress = Math.min(100, this.washProgress + 2);

    const bathFill = document.getElementById("bath-fill");
    if (bathFill) bathFill.style.width = `${this.washProgress}%`;

    if (this.dFill) this.dFill.style.width = `${this.washProgress}%`;

    if (this.washProgress >= 100) {
      await dialogue.show([{ text: "목욕 완료." }]);
      this.stop();
      showScreen("home");
    }
  },

  stop() {
    const screen = document.getElementById("screen-bath");
    if (this.smileTimer) clearInterval(this.smileTimer);
    this.smileTimer = null;

    if (screen && this.onMove) screen.removeEventListener("pointermove", this.onMove);
    this.onMove = null;

    if (screen) {
      screen.classList.remove("sponge-cursor");
      screen.classList.remove("shower-cursor");
    }

    const dProg = document.getElementById("dialogue-progress");
    if (dProg) dProg.style.display = "none";
  }
};


window.addEventListener("load", async () => {
  try {
    const state = await apiGet("/api/status");
    renderHUD(state);
  } catch (e) {
    console.error("status fetch failed", e);
  }

  try {
    document.querySelectorAll(".app-btn").forEach(btn => {
      btn.addEventListener("click", async () => {
        const type = btn.dataset.event;

        if (type === "walk") {
          showScreen("walk");
          await apiPost("/api/walk/start", {});
          walk.start();
        } else if (type === "cook") {
          showScreen("cook");
          cook.start();
        } else if (type === "bath") {
          showScreen("bath");
          bath.start();
        }
      });
    });

    const a = document.getElementById("btn-attack");
    const w = document.getElementById("btn-watch");
    const r = document.getElementById("btn-run");
    if (a) a.addEventListener("click", () => walk.choose("attack"));
    if (w) w.addEventListener("click", () => walk.choose("watch"));
    if (r) r.addEventListener("click", () => walk.choose("run"));

    const bathExit = document.getElementById("bath-exit");
    if (bathExit) {
      bathExit.addEventListener("click", () => {
        bath.stop();
        showScreen("home");
      });
    }

    showScreen("home");
  } catch (e) {
    console.error("boot bind failed", e);
  }
});

4. css

body, html { margin: 0; padding: 0; width: 100%; height: 100%; overflow: hidden; }

#walk-info { display: none !important; }
.walk-exit{
  position:absolute;
  right:16px;
  top:16px;
  z-index: 60;
}

.ui-layer{
  position:absolute;
  inset:0;
  z-index:1000;
  pointer-events: none; 
}


#dialogue-layer{
  display:block;
  pointer-events: none;
  background: rgba(0,0,0,0);
}

.dialogue-progress{
  margin-top: 10px;
  width: 100%;
  height: 10px;
  background: rgba(255,255,255,0.18);
  border-radius: 999px;
  overflow: hidden;
}
#dialogue-progress-fill{
  width: 0%;
  height: 100%;
  background: rgba(120,200,255,0.9);
}


#dialogue-box{
   pointer-events:auto;
  position:absolute;
  left:50%;
  bottom:6px;
  transform:translateX(-50%);
  width:min(640px, 94vw);
  min-height:92px;
  background:rgba(0,0,0,0.75);
  border:2px solid rgba(255,255,255,0.85);
  border-radius:12px;
  padding:12px 14px;
  color:#fff;
  font-family: system-ui, -apple-system, sans-serif;
  box-sizing:border-box;
}

#encounter-ui { pointer-events: auto; z-index: 200; }
#screen-walk { z-index: 1; } 

#dialogue-name{
  font-size:13px;
  opacity:0.9;
  margin-bottom:6px;
}

#dialogue-text{
  font-size:16px;
  line-height:1.35;
  white-space:pre-wrap;
  word-break:keep-all;
}


#dialogue-hint{
  position:absolute;
  right:12px;
  bottom:10px;
  font-size:14px;
  opacity:0.85;
  animation: blink 0.9s infinite steps(2, end);
}

@keyframes blink{
  50%{ opacity:0.15; }
}


#screen-bath.sponge-cursor { cursor: url("/static/images/ui/cursor_sponge.png") 16 16, auto; }
#screen-bath.shower-cursor { cursor: url("/static/images/ui/cursor_shower.png") 16 16, auto; }

#screen-bath .bg{ z-index: 1;}
#bubble-layer { display: none;position:absolute;
  inset:0;
  z-index:20;
  pointer-events:none;}

.bubble{ position:absolute;
  width:72px;
  height:72px;
  background: url("/static/images/ui/bubble.png") center/contain no-repeat;
  opacity: 0.95;}
  
#bath-marill{position:absolute;
  left:50%;
  top:56%;
  transform:translate(-50%,-50%);
  width:220px;
  z-index:40;}
#bath-ui{ position:absolute;
  left:50%;
  top:72%;
  transform:translateX(-50%);
  width:min(520px, 92vw);
  display:flex;
  flex-direction:column;
  gap:10px;
  align-items:flex-start;
  pointer-events:auto;}



#game-viewport { position: relative; width: 100vw; height: 100vh; }
.screen { position: absolute; inset: 0; }
.bg { position: absolute; inset: 0; width: 100%; height: 100%; object-fit: cover; }

.character { position: absolute; bottom: 20%; left: 45%; width: 140px; }
.walk-ani { animation: walkbob 0.6s infinite alternate; }
@keyframes walkbob { from { transform: translateY(0); } to { transform: translateY(-6px); } }

.walk-marill{
  position:absolute;
  left:50%;
  top:60%;
  transform:translate(-50%,-50%);
  width:160px;
  animation: walkJitter 0.35s infinite alternate;
  z-index: 30;
}

@keyframes walkJitter{
  from { transform: translate(-50%,-50%) translate(-2px,-2px); }
  to   { transform: translate(-50%,-50%) translate(2px,2px); }
}

.enemy-img{
  position:absolute;
  left:50%;
  top:18%;
  transform:translateX(-50%);
  width:140px;
  z-index: 35;
}

#wandering-marill-container {
  position: absolute;
  top: 60%;
  left: 50%;
  transform: translate(-50%, -50%);
  transition: top 0.25s linear, left 0.25s linear;
  transform-origin: 50% 70%;
  animation: waddle 0.9s infinite ease-in-out;
}

@keyframes waddle {
  0%   { transform: translate(-50%, -50%) translateY(0) rotate(-3deg); }
  50%  { transform: translate(-50%, -50%) translateY(-2px) rotate(3deg); }
  100% { transform: translate(-50%, -50%) translateY(0) rotate(-3deg); }
}

#wandering-marill.facing-left { transform: scaleX(-1); }

.bubble {
  position: absolute;
  width: 72px;
  height: 72px;
  border-radius: 50%;
  background: url("/static/images/ui/bubble.png") center/contain no-repeat;
  opacity: 0.95;
}

#smartphone-container {
  position: absolute;
  bottom: 20px;
  right: 20px;
  width: 300px;
  height: auto;
}
#phone-frame-img { width: 100%; display: block; }

.app-screen-overlay {
  position: absolute;
  top: 12%;
  left: 8%;
  width: 84%;
  height: 75%;
  overflow: hidden;
}
.app-grid {
  display: grid;
  grid-template-columns: repeat(2, 1fr);
  gap: 15px;
  padding: 10px;
}
.app-btn {
  background: none;
  border: none;
  cursor: pointer;
  transition: transform 0.1s;
}
.app-btn img { width: 100%; max-width: 60px; -webkit-user-drag: none; user-select: none; }
.app-btn span { display: block; color: white; font-size: 12px; margin-top: 5px; }
.app-btn:active { transform: scale(0.9); filter: brightness(0.8); }

#hud {
  position: absolute;
  top: 10px; left: 10px;
  z-index: 50;
  background: rgba(0,0,0,0.35);
  padding: 8px 10px;
  border-radius: 10px;
  color: #fff;
  font-family: system-ui, -apple-system, sans-serif;
  display: flex;
  align-items: center;
  gap: 12px;
}
#hud-hp { display: flex; gap: 3px; }
.heart { font-size: 18px; }
.heart.off { opacity: 0.25; }
#hud-items { display: flex; gap: 10px; }

.modal {
  position: absolute;
  left: 50%; top: 55%;
  transform: translate(-50%, -50%);
  background: rgba(0,0,0,0.65);
  color: white;
  padding: 14px 16px;
  border-radius: 12px;
  z-index: 40;
  min-width: 260px;
}
.panel {
  position: absolute;
  left: 50%; top: 50%;
  transform: translate(-50%, -50%);
  background: rgba(0,0,0,0.55);
  color: white;
  padding: 16px 16px;
  border-radius: 12px;
  z-index: 30;
  width: min(420px, 92vw);
}
.row { display: flex; gap: 8px; margin-top: 10px; flex-wrap: wrap; }
button { padding: 10px 12px; border-radius: 10px; border: none; cursor: pointer; }
.hint { opacity: 0.9; font-size: 13px; margin-top: 6px; }

.toast {
  position: absolute;
  left: 50%; top: 20%;
  transform: translateX(-50%);
  background: rgba(0,0,0,0.45);
  color: white;
  padding: 10px 14px;
  border-radius: 999px;
  z-index: 25;
}


#gauge { width: 100%; height: 16px; background: rgba(255,255,255,0.2); border-radius: 999px; overflow: hidden; margin-top: 10px; }
#gauge-fill { width: 50%; height: 100%; background: rgba(255,200,0,0.9); }

.feed .post { display: grid; gap: 8px; }
.post-img { width: 100%; height: 180px; object-fit: cover; border-radius: 10px; opacity: 0.9; }

.bath-center{
  position:absolute;
  left:50%;
  top:54%;
  transform:translate(-50%,-50%);
  z-index: 45;
  display:flex;
  flex-direction:column;
  align-items:center;
  gap:12px;
  pointer-events:none; 
}

.bath-marill{
  width:220px; 
  display:block; position: static; transform: none;
}

.bath-progress{
  display:block;
  width:min(360px, 86vw);
  height:16px;
  background: rgba(255,255,255,0.35);
  border-radius:999px;
  overflow:hidden;
  z-index:9999;
  position:relative;
}

#bath-fill{
  display:block;
  width:0%;
  height:100%;
  background: rgba(120,200,255,0.9);
}

#bath-marill{
  position: static !important;
  left:auto !important;
  top:auto !important;
  transform:none !important;
  z-index: auto !important;
}

.bath-panel{
  top:78% !important;
}

.cook-stage{
  position:absolute;
  left:50%;
  top:50%;
  transform:translate(-50%,-50%);
  width:min(520px, 92vw);
  z-index: 35;
  display:flex;
  flex-direction:column;
  align-items:center;
  gap:12px;
  pointer-events:auto;
  background: rgba(0,0,0,0.55);
  border-radius:12px;
  padding:16px;
  box-sizing:border-box;
}

.cook-stage-img{
  width:min(320px, 70vw);
  display:block;
}

.cook-gauge{
  width:100%;
  height:16px;
  background: rgba(255,255,255,0.2);
  border-radius:999px;
  overflow:hidden;
}

.cook-phase{
  font-size:14px;
  opacity:0.95;
}

.cook-bottom{
  justify-content:center;
}

.cook-reaction-img{
  width:min(220px, 50vw);
  display:block;
  opacity:0.98;
}

.cook-result-text{
  width:100%;
  white-space:pre-wrap;
  word-break:keep-all;
  font-size:14px;
  line-height:1.35;
  opacity:0.95;
}

#cook-phase,
#cook-hint,
.cook-result-text {
  color: #ffffff;
  text-shadow:
    0 1px 2px rgba(0,0,0,0.8),
    0 0 6px rgba(0,0,0,0.6);
}

.cook-stage {
  background: rgba(0, 0, 0, 0.65);
}

[알고리즘 스터디] 9주차 결

sourceoftax — Tue, 16 Dec 2025 20:57:35 +0900

한 학기 동안의 알고리즘 스터디 끝...

첫 시작 실버3에서 골드5 달성 성공

1129

#include <bits/stdc++.h>
using namespace std;

int main() {
double xA, yA, xB, yB, xC, yC;
cin >> xA >> yA >> xB >> yB >> xC >> yC;

double cross = (xB - xA) * (yC - yA) - (yB - yA) * (xC - xA);


if (cross == 0) {
cout << -1 << '\n';
return 0;
}

auto dist = [&](double x1, double y1, double x2, double y2) {
return hypot(x1 - x2, y1 - y2);
};

double AB = dist(xA, yA, xB, yB);
double BC = dist(xB, yB, xC, yC);
double AC = dist(xA, yA, xC, yC);

double P1 = 2 * (AB + BC);
double P2 = 2 * (AB + AC);
double P3 = 2 * (AC + BC);

double mx = max({P1, P2, P3});
double mn = min({P1, P2, P3});

cout << fixed << setprecision(10) << (mx - mn) << "\n";
return 0;
}

1130

A, B = input().split()
n, m = len(A), len(B)

min_diff = float('inf')

for i in range(m - n + 1):
    diff = 0
    for j in range(n):
        if A[j] != B[i + j]:
            diff += 1
    min_diff = min(min_diff, diff)

print(min_diff)

1201

x, y, w, s = map(int, input().split())

if s > 2 * w:
    print((x + y) * w)

elif s <= w:
    if abs(x - y) % 2 == 0:
        print(max(x, y) * s)
    else:
        print((max(x, y) - 1) * s + w)

else:
    block = min(x, y)
    rest = abs(x - y)
    print(block * s + rest * w)

1202

S = input().strip()

suffixes = [S[i:] for i in range(len(S))]  
suffixes.sort()                           

for suf in suffixes:
    print(suf)

1203

n = int(input())
numbers = list(map(int, input().split()))

unique_numbers = sorted(set(numbers))

print(*unique_numbers)

1204

n, m= map(int, input().split())

visited = [False] * (n+1)
stack = []

def dfs():
    if len(stack) == m:
        print(*stack)
        return
        
    for num in range(1, n+1):
        if not visited[num]:
            visited[num] = True
            stack.append(num)

            dfs()

            visited[num] = False
            stack.pop()

dfs()

1207

import sys
input = sys.stdin.readline

N, M = map(int, input().split())
mat = [list(map(int, input().split())) for _ in range(N)]

ans = -10**15

for left in range(M):
    temp = [0] * N
    for right in range(left, M):
        for i in range(N):
            temp[i] += mat[i][right]

        current = temp[0]
        best = temp[0]
        for i in range(1, N):
            current = max(temp[i], current + temp[i])
            best = max(best, current)

        ans = max(ans, best)

print(ans)

[알고리즘 스터디] 8주차 결산

sourceoftax — Tue, 16 Dec 2025 20:39:46 +0900

1122

def d(n):
    return n + sum(map(int, str(n)))

generated = set()

for i in range(1, 10001):
    generated.add(d(i))

for i in range(1, 10001):
    if i not in generated:
        print(i)

1123

num = int(input())

line = 1
while num > line * (line + 1) // 2:
    line += 1

line_sum = line * (line + 1) // 2
pos = line_sum - num

if line % 2 == 0:  
    numerator = 1 + pos
    denominator = line - pos
else:  
    numerator = line - pos
    denominator = 1 + pos

print(f"{numerator}/{denominator}")

1124

#include <iostream>
#include <vector>
#include <string>
using namespace std;

int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);

int N, M;
cin >> N >> M;

vector<string> board(N);
for (int i = 0; i < N; i++) {
cin >> board[i];
}

int maxSize = 1; 


for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {


for (int size = 1; i + size < N && j + size < M; size++) {

if (board[i][j] == board[i][j + size] &&
board[i][j] == board[i + size][j] &&
board[i][j] == board[i + size][j + size])
{
maxSize = max(maxSize, size + 1);}
}
}
}

cout << maxSize * maxSize << "\n";
return 0;
}

1125

#include <iostream>
#include <vector>
using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int N, K;
    cin >> N >> K;

    vector<int> temp(N);
    for (int i = 0; i < N; i++) {
        cin >> temp[i];
    }

    int currentSum = 0;
    for (int i = 0; i < K; i++) {
        currentSum += temp[i];
    }

    int maxSum = currentSum;

    for (int i = K; i < N; i++) {
        currentSum += temp[i] - temp[i - K];
        if (currentSum > maxSum) {
            maxSum = currentSum;
        }
    }

    cout << maxSum << "\n";

    return 0;
}

1126

#include <iostream>
#include <stack>
#include <string>
using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int N;
    cin >> N;

    int answer = 0;

    while (N--) {
        string s;
        cin >> s;

        stack<char> st;
        for (char c : s) {
            if (!st.empty() && st.top() == c) {
                st.pop(); 
            } else {
                st.push(c);
            }
        }

        if (st.empty())
            answer++;
    }

    cout << answer << "\n";
    return 0;
}

1128

#include <bits/stdc++.h>
using namespace std;

const int INF = 1e9;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n, m;
    cin >> n >> m;

    vector<vector<int>> dist(n+1, vector<int>(n+1, INF));
    vector<vector<int>> next(n+1, vector<int>(n+1, 0));

    for (int i = 1; i <= n; i++) dist[i][i] = 0;

    for (int i = 0; i < m; i++) {
        int a, b, c;
        cin >> a >> b >> c;
        if (dist[a][b] > c) {
            dist[a][b] = c;
            next[a][b] = b;   
        }
    }

    for (int k = 1; k <= n; k++) {
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                if (dist[i][j] > dist[i][k] + dist[k][j]) {
                    dist[i][j] = dist[i][k] + dist[k][j];
                    next[i][j] = next[i][k];  
                }
            }
        }
    }

    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            if (dist[i][j] == INF) cout << 0 << " ";
            else cout << dist[i][j] << " ";
        }
        cout << "\n";
    }

    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            if (dist[i][j] == INF || i == j) {
                cout << 0 << "\n";
                continue;
            }

            vector<int> path;
            int cur = i;
            while (cur != j) {
                path.push_back(cur);
                cur = next[cur][j];
            }
            path.push_back(j);

            cout << path.size() << " ";
            for (int x : path) cout << x << " ";
            cout << "\n";
        }
    }

    return 0;
}

[알고리즘 스터디] 7주차 결산

sourceoftax — Mon, 15 Dec 2025 21:55:01 +0900

1116

#include <bits/stdc++.h>
using namespace std;

long long n, l, w, h;

bool can(double a) {
    return (long long)(l / a) * (long long)(w / a) * (long long)(h / a) >= n;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    cin >> n >> l >> w >> h;

    double low = 0, high = max({l, w, h});
    
    for (int i = 0; i < 10000; i++) {  
        double mid = (low + high) / 2;
        if (can(mid))
            low = mid;
        else
            high = mid;
    }

    cout << fixed << setprecision(10) << low << "\n";
    return 0;
}

1117

#include <iostream>
#include <stack>
using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    string word;
    cin >> word;

    int n;
    cin >> n;

    stack<char> left, right;

    for (char c : word) left.push(c);

    while (n--) {
        char cmd;
        cin >> cmd;
        
        if (cmd == 'L') {
            if (!left.empty()) {
                right.push(left.top());
                left.pop();
            }
        }
        else if (cmd == 'D') {
            if (!right.empty()) {
                left.push(right.top());
                right.pop();
            }
        }
        else if (cmd == 'B') {
            if (!left.empty()) left.pop();
        }
        else if (cmd == 'P') {
            char x;
            cin >> x;
            left.push(x);
        }
    }

    string result;
    while (!left.empty()) {
        right.push(left.top());
        left.pop();
    }
    while (!right.empty()) {
        result += right.top();
        right.pop();
    }

    cout << result;
}

1118

#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;

int main() {
int num;
const int Max = 2 * 123456;
vector<bool> arr(Max, true);
arr[0] = arr[1] = false;

for (int i = 2; i * i < Max; i++){
if(arr[i]){
for (int j = i*i; j < Max; j += i){
arr[j] = false;}
				}
}

while (true){
cin >> num;
if(num == 0) break;

int count = 0;
for(int k = num+1; k < (num *2) +1;k++){
if(arr[k]) count++;
}
cout << count << "\n";
}


return 0;
}

1119

#include <iostream>
#include <vector>
using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int num, newscore, p;
    cin >> num >> newscore >> p;

    vector<int> arr(num);   
    for (int i = 0; i < num; i++)
        cin >> arr[i];

    if (num == 0) {
        cout << 1;
        return 0;
    }

    if (num == p && newscore <= arr[num - 1]) {
        cout << -1;
        return 0;
    }

    int rank = 1;
    for (int i = 0; i < num; i++) {
        if (arr[i] > newscore) rank++;
        else break;
    }

    cout << rank;
    return 0;
}

1120

#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>   
using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);

    int num;
    cin >> num;
    vector<long long> arr(num);
    for (int i = 0; i < num; i++)
        cin >> arr[i];

    vector<int> idx(num);
    iota(idx.begin(), idx.end(), 0);

    sort(idx.begin(), idx.end(), [&](int x, int y) {
        if (arr[x] == arr[y]) return x < y;
        return arr[x] < arr[y];
    });

    vector<int> p(num);

    for (int pos = 0; pos < num; pos++) {
        p[idx[pos]] = pos;
    }

    for (int i = 0; i < num; i++)
        cout << p[i] << " ";
    cout << "\n";

    return 0;
}

1121

num, s = map(int, input().split())
arr = list(map(int, input().split()))

left = 0
sum_val = 0
answer = float('inf')

for right in range(num):
    sum_val += arr[right]

    while sum_val >= s:
        answer = min(answer, right - left + 1)
        sum_val -= arr[left]
        left += 1

print(0 if answer == float('inf') else answer)

[알고리즘 스터디] 6주차 결산

sourceoftax — Mon, 15 Dec 2025 21:50:15 +0900

1108

#include <iostream>
using namespace std;

long long p[101]; 

int main() {


    int k;
    cin >> k;

    p[1] = p[2] = p[3] = 1;
    p[4] = p[5] = 2;

    for (int i = 6; i <= 100; i++) {
        p[i] = p[i - 1] + p[i - 5];
    }

    while (k--) {
        int n;
        cin >> n;
        cout << p[n] << '\n';
    }

    return 0;
}

1109

num, n = map(int, input().split())
count = 0
arr = set()  

for _ in range(num):
    arr.add(input())

for _ in range(n):
    word = input()
    if word in arr:
        count += 1

print(count)

1110

n, k = map(int, input().split())
arr = list(map(int, input().split()))

count = 0
found = False

for i in range(n - 1, 0, -1):  
    max_idx = i
    for j in range(i - 1, -1, -1):
        if arr[j] > arr[max_idx]:
            max_idx = j

    if max_idx != i:
        arr[i], arr[max_idx] = arr[max_idx], arr[i]
        count += 1
        if count == k:
            print(arr[max_idx], arr[i])
            found = True
            break

if not found:
    print(-1)

1111

#include <iostream>
#include <algorithm>
#include <vector>
#include <map>
using namespace std;

int main() {
int casenum, num;

cin >> casenum;

for (int i = 0; i < casenum; i++){
int count(1);
cin >> num;
vector<pair<string, string>> arr(num);
map<string, int> typeCount;

for (int j = 0; j < num; j++){
cin >> arr[j].first >> arr[j].second;
typeCount[arr[j].second]++;
}

for (auto &p : typeCount) {
count *= (p.second + 1);
}

count -= 1;

cout << count << "\n";

}


return 0;
}

1112

#include <iostream>
#include <vector>
using namespace std;

int main() {

    int num(0), caseNum(0), k(0);
    scanf("%d %d", &num, &caseNum);

    vector<int> arr(num + 1, 0); 
    for (int i = 1; i <= num; i++) {
        scanf("%d", &k);
        arr[i] = arr[i - 1] + k; 
    }

    for (int i = 0; i < caseNum; i++) {
        int startNum(0), endNum(0);
        scanf("%d %d", &startNum, &endNum);
        printf("%d\n", arr[endNum] - arr[startNum - 1]);
    }
    return 0;
}

1113

def cutSum(arr, height):
total = 0
for ch in arr:
if ch > height:
total += ch - height
return total

def binary_search(arr, minsum):
left = 0
right = max(arr)
result = 0

while left <= right:
mid = (left + right) // 2
cutsum = cutSum(arr, mid)

if cutsum >= minsum:
result = mid
left = mid +1
else:
right = mid -1

return result

num, minsum = map(int, input().split())
arr = list(map(int, input().split()))


print(binary_search(arr, minsum))

1114

def func(start):
    heap = []
    dist[start] = 0
    heapq.heappush(heap, (0, start))

    while heap:
        current_cost, now = heapq.heappop(heap)

        if dist[now] < current_cost:
            continue

        for nxt, cost in graph[now]:
            new_cost = current_cost + cost
            if new_cost < dist[nxt]:
                dist[nxt] = new_cost
                prev[nxt] = now
                heapq.heappush(heap, (new_cost, nxt))

import sys
import heapq
input = sys.stdin.readline

n = int(input())
m = int(input())

graph = [[] for _ in range(n+1)]
for _ in range(m):
    a, b, cost = map(int, input().split())
    graph[a].append((b, cost))

start, end = map(int, input().split())

nf = float('inf')
dist = [nf] * (n+1)
prev = [0] * (n+1)

func(start)


path = []
cur = end
while cur != 0:
    path.append(cur)
    cur = prev[cur]

path.reverse()


print(dist[end])         
print(len(path))         
print(*path)

[알고리즘 스터디] 5주차 결산

sourceoftax — Mon, 15 Dec 2025 21:43:27 +0900

왜 갑자기 11월로 점프함? 나태함 미쳤네

라는 말은 스톱

중간고사 기간에는 스터디도 쉬어갑니다.

1101

casenum = int(input())

dp = [(0, 0)] * 41
dp[0] = (1, 0) 
dp[1] = (0, 1)  

for i in range(2, 41):
    dp[i] = (dp[i-1][0] + dp[i-2][0], dp[i-1][1] + dp[i-2][1])

for _ in range(casenum):
    n = int(input())
    print(dp[n][0], dp[n][1])

1102

#include <iostream>
using namespace std;

int main() {
	int num;
	int sum(0);
	int count(0);
	int stick = 64;
	cin >> num;
	
	while (sum != num){
		if (stick > num - sum){
			stick /= 2;
		}
		else{
			sum += stick;
			count ++;
			}
	}
	cout << count;
    return 0;
}

1103

num = int(input())

dp = [0] * (num + 2)
dp[1] = 1
dp[2] = 2

for i in range(3, num + 1):
    dp[i] = (dp[i - 1] + dp[i - 2]) % 15746  

print(dp[num])

1104

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

int main() {
	int num, count;
	scanf("%d %d", &num, &count);
	vector<int> arr(num);
	
	for (int i = 0; i < num; i++){
		scanf("%d", &arr[i]);
	}
	nth_element(arr.begin(), arr.begin() + (count - 1), arr.end());
	printf("%d", arr[count-1]);
	
    return 0;
}

1105

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

bool compare(int i, int j){
	return i > j;
}

int main() {
	int num, people, count = 0;
	int result = 0;
	cin >> num >> people;
	
	vector<int> arr(people);
	vector<int> sum(people);
	
	for (int i = 0; i < people; i++){
		cin >> arr[i];
	}
	sort(arr.begin(), arr.end(), compare);
	
	for (int i = 0; i < people; i++){
		sum[i] = min(num, i + 1) * arr[i];
		
		if (sum[i] > result) {            
			result = sum[i];
			count = arr[i];
	}
	}
	cout << count << " " << result;
	
    return 0;
}

1106

def merge(arr, p, q, r):
i = p
j = q+1
t = 0
global count, answer, n

while (i <= q and j <= r):
if (arr[i] <= arr[j]):
tmp[t] = arr[i]
t += 1
i += 1
else:
tmp[t] = arr[j]
t += 1
j += 1

#하나가 i=q, j=r 둘이 같은 경우, 근데 만약 하나 더 짧으면
while (i <= q):
tmp[t] = arr[i]
t = t+1
i=i+1
while(j <= r):
tmp[t] = arr[j]
t = t+1
j = j+1
i = p
t = 0
while (i <= r):
arr[i] = tmp[t]
count += 1

if(count == n):
answer = arr[i]
t += 1
i += 1



def mergesort(arr, p, r):
if (p < r):
q = (p + r) // 2

mergesort(arr, p, q)
mergesort(arr,q+1, r)
merge(arr, p, q, r)



length, n = map(int, input().split())
arr = list(map(int, input().split()))

tmp = [0]*(len(arr))
count = 0
p = 0
r = len(arr)-1
answer = -1
mergesort(arr, p, r)
print(answer)

1107

#include <iostream>
#include <cmath>
using namespace std;

bool func(long long num) {
long long numRoot = sqrt(num);
return num == numRoot * numRoot;
}

int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);

int caseNum;
cin >> caseNum;

for (int i = 0; i < caseNum; i++) {
long long num;
cin >> num;
cout << func(num);
if (i != caseNum - 1) cout << " ";
}

return 0;
}

[알고리즘 스터디] 4주차 결산

sourceoftax — Fri, 12 Dec 2025 20:20:05 +0900

1012

def func(word):
    seen = set()
    prev = ''
    for ch in word:
        if ch != prev:
            if ch in seen:
                return False
            seen.add(prev)
        prev = ch
    return True

num = int(input())
count = 0

for i in range(num):
    word = input()
    if func(word):
        count += 1

print(count)

1013

num = int(input())
arr = []
for i in range(num):
    word = input()

    if(word in arr):
        pass
    else:
        arr.append(word)

arr.sort(key=lambda x: (len(x), x))

for ch in arr:
    print(ch)

1015

num, length = map(int, input().split())

for l in range(length, 101):  
    num2 = num - (l * (l - 1) // 2)

    if num2 < 0:
        break  

    if num2r % l == 0:  
        start = num2 // l
        print(*[start + i for i in range(l)])
        exit()

print(-1)

1016

num = int(input())
arr = set(input().split())

num2 = int(input())
cards = input().split()

for card in cards:
    if card in arr:
        print(1, end=' ')
    else:
        print(0, end=' ')

1017

[알고리즘 스터디] 3주차 결산

sourceoftax — Fri, 12 Dec 2025 20:17:10 +0900

num = int(input())
d = [0] * (num+1)

for i in range(1, num + 1):
    d[i] = i  
    j = 1
    while j * j <= i:
        d[i] = min(d[i], d[i - j * j] + 1)
        j += 1

print(d[num])

1004

import collections

caseNum = int(input())
arr = input().split()
counter = collections.Counter(arr)

num = int(input())
searchNums = input().split()

for s in searchNums:
    print(counter[s], end=' ')

1005

#include <iostream>
#include <vector>
#include <utility>
#include <algorithm>
using namespace std;

int main() {
	int num(0);
	cin >> num;
	int x, y;
    vector <pair<int, int>> arr;
	
	for (int i = 0; i < num; i++){
		cin >> x >> y;
		arr.push_back({x,y});
	}
	sort(arr.begin(),arr.end());
	
	for (auto &v : arr) {
        cout << v.first << " " << v.second << "\n";
    }
    return 0;
}

1006

num, maxWeight = map(int, input().split())

d = [0] * (maxWeight+1)
for i in range(num):
    weight, value = map(int, input().split())
    for w in range(maxWeight, weight - 1, -1): 
        d[w] = max(d[w], d[w - weight]+ value)
print(d[maxWeight])

1007

이날 레제 극장판을 너무 감명깊게 봐서 폭발하는 문제를 찾아서 풀었음

text = input()
bomb = input()

stack = []
bomb_len = len(bomb)

for ch in text:
    stack.append(ch)

    if len(stack) >= bomb_len and ''.join(stack[-bomb_len:]) == bomb:
        del stack[-bomb_len:]

    
result = ''.join(stack)
print(result if result else "FRULA")

1008

casenum = int(input())

for i in range(casenum):
    num = int(input())
    d = [0] * (num + 1)

    d[1] = 1
    if num >= 2:
        d[2] = 2
    if num >= 3:
        d[3] = 4

    for j in range(4, num +1):
        d[j] = d[j-1] + d[j-2] + d[j-3]
    print(d[num])

1009

def func(num):
    if(num <= 1):
        return 1
    return num * func(num-1)

num = int(input())
facNum = func(num)
count = 0

while facNum % 10 == 0:
    count += 1
    facNum //= 10

print(count)

1010

num = int(input())
d = [0] * (num+1)

for i in range(1, num + 1):
    d[i] = i  
    j = 1
    while j * j <= i:
        d[i] = min(d[i], d[i - j * j] + 1)
        j += 1

print(d[num])

아주 유용하고 편리한 생년월일 입력 프로그램

sourceoftax — Mon, 8 Dec 2025 22:10:55 +0900

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

여러분의 실력을 뽐내보세요

사용 코드 1(음악 넣고 노드 뽑는 프로그램)

import librosa
import numpy as np
import json
import os


WAV_FILE = "fantaisie.wav"
OUTPUT_FILE = "beatmap.json"

def create_beatmap():
    if not os.path.exists(WAV_FILE):
        print(f"오류. {WAV_FILE} 파일이 없습니다")
        return

    print("음악 분석 중")
    
    y, sr = librosa.load(WAV_FILE, sr=22050)

    onset_env = librosa.onset.onset_strength(y=y, sr=sr)
    onset_frames = librosa.onset.onset_detect(
        onset_envelope=onset_env, 
        sr=sr, 
        wait=3,      
        delta=0.04   
    )
    
    timestamps = librosa.frames_to_time(onset_frames, sr=sr)
    
    timestamps_list = timestamps.tolist()

    with open(OUTPUT_FILE, 'w') as f:
        json.dump(timestamps_list, f)

    print(f"{len(timestamps_list)}개의 노트가 생성되었습니다")
    print(f"결과가 {OUTPUT_FILE}에 저장되었습니다")

if __name__ == "__main__":
    create_beatmap()

사용 코드 2(메인 코드)

import sys
import os
import time
import json
import random
from PyQt5.QtWidgets import (QApplication, QWidget, QLabel, QPushButton, 
                             QVBoxLayout, QHBoxLayout, QStackedWidget)
from PyQt5.QtCore import QTimer, Qt, QUrl
from PyQt5.QtGui import QPainter, QColor, QFont, QPen
from PyQt5.QtMultimedia import QMediaPlayer, QMediaContent

WINDOW_WIDTH = 400
WINDOW_HEIGHT = 600
NOTE_SPEED = 8
HIT_Y = 500
HIT_RANGE = 70


class RhythmGameWidget(QWidget):
    def __init__(self, main_window):
        super().__init__()
        self.main_window = main_window
        self.score = 0
        self.notes = []
        self.is_playing = False
        self.is_game_over = False

        self.timer = QTimer()
        self.timer.timeout.connect(self.game_loop)

        self.score_font = QFont("Arial", 24, QFont.Bold)
        self.gameover_font = QFont("Arial", 36, QFont.Bold)

        self.player = QMediaPlayer()
        self.hit_player = QMediaPlayer()

        bgm = QUrl.fromLocalFile(os.path.abspath("fantaisie.wav"))
        hit = QUrl.fromLocalFile(os.path.abspath("hit.mp3"))

        self.player.setMedia(QMediaContent(bgm))
        self.hit_player.setMedia(QMediaContent(hit))

        self.map_file = "beatmap.json"
        self.note_timestamps = []

        if os.path.exists(self.map_file):
            with open(self.map_file, 'r') as f:
                self.note_timestamps = json.load(f)

        self.current_note_index = 0
        self.start_time = 0

    def start_game(self):
        if not self.note_timestamps:
            self.main_window.show_status("오류. beatmap.json 파일이 없습니다")
            self.main_window.back_to_form()
            return

        self.score = 0
        self.notes = []
        self.current_note_index = 0
        self.is_playing = True
        self.is_game_over = False

        self.start_time = time.time()

        self.timer.start(16)
        self.setFocus()

        self.player.stop()
        self.player.play()

    def stop_game(self):
        if not self.is_playing:
            return

        self.is_playing = False
        self.is_game_over = True

        QTimer.singleShot(20, self._finish_stop)

    def _finish_stop(self):
        self.timer.stop()
        self.player.stop()
        self.update()

        QTimer.singleShot(700, self._safe_return)

    def _safe_return(self):
        self.main_window.finish_game(self.score)

    def play_hit_sound(self):
        self.hit_player.stop()
        self.hit_player.play()

    def game_loop(self):
        if not self.is_playing:
            return

        now = time.time() - self.start_time

        while self.current_note_index < len(self.note_timestamps):
            t = self.note_timestamps[self.current_note_index]
            if t <= now:
                x = random.randint(0, WINDOW_WIDTH - 50)
                self.notes.append({'x': x, 'y': -20})
                self.current_note_index += 1
            else:
                break

        for note in self.notes:
            note['y'] += NOTE_SPEED
            if note['y'] > WINDOW_HEIGHT:  
                self.stop_game()
                return

        self.update()

    def paintEvent(self, event):
        p = QPainter(self)
        p.setRenderHint(QPainter.Antialiasing)

        p.fillRect(self.rect(), QColor("#222222"))

        if self.is_game_over:
            p.setPen(QColor("#FF4444"))
            p.setFont(self.gameover_font)
            p.drawText(self.rect(), Qt.AlignCenter, "입력 완료")

            p.setPen(QColor("white"))
            p.setFont(self.score_font)
            p.drawText(self.rect().adjusted(0, 90, 0, 0),
                       Qt.AlignCenter, f"입력된 정보: {self.score}")
            return

        pen = QPen(QColor(255, 255, 255))
        pen.setWidth(2)
        p.setPen(pen)
        p.drawLine(0, HIT_Y, WINDOW_WIDTH, HIT_Y)

        p.setBrush(QColor("#66CCFF"))
        p.setPen(Qt.NoPen)
        for note in self.notes:
            p.drawRect(note['x'], note['y'], 50, 20)

        p.setPen(QColor("#66CCFF"))
        p.setFont(self.score_font)
        p.drawText(self.rect(),
                   Qt.AlignTop | Qt.AlignHCenter,
                   f"COMBO: {self.score}")

    def keyPressEvent(self, event):
        if not self.is_playing:
            return

        if event.key() == Qt.Key_Space:
            for note in self.notes[:]:
                if HIT_Y - HIT_RANGE < note['y'] < HIT_Y + HIT_RANGE:
                    self.notes.remove(note)
                    self.score += 1
                    self.play_hit_sound()
                    break


class MainWindow(QWidget):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Input System")
        self.setFixedSize(WINDOW_WIDTH, WINDOW_HEIGHT)
        self.setStyleSheet("background-color: #f9f9f9; font-family: 'Malgun Gothic';")

        self.stack = QStackedWidget(self)
        self.form_widget = QWidget()
        self.setup_form_ui()
        self.game_widget = RhythmGameWidget(self)

        self.stack.addWidget(self.form_widget)
        self.stack.addWidget(self.game_widget)

        layout = QVBoxLayout(self)
        layout.addWidget(self.stack)
        layout.setContentsMargins(0, 0, 0, 0)

        self.current_target = None

    def setup_form_ui(self):
        layout = QVBoxLayout()
        layout.setAlignment(Qt.AlignCenter)
        layout.setSpacing(20)

        title = QLabel("생년월일 입력")
        title.setStyleSheet("font-size: 24px; font-weight: bold; color: #333;")
        title.setAlignment(Qt.AlignCenter)

        self.status_label = QLabel("입력된 정보는 사용 후 파기됩니다")
        self.status_label.setStyleSheet("font-size: 14px; color: #666;")
        self.status_label.setAlignment(Qt.AlignCenter)

        input_layout = QHBoxLayout()
        self.btn_year = self.create_input_btn("YYYY")
        self.btn_month = self.create_input_btn("MM")
        self.btn_day = self.create_input_btn("DD")

        input_layout.addWidget(self.btn_year)
        input_layout.addWidget(self.btn_month)
        input_layout.addWidget(self.btn_day)

        btn_submit = QPushButton("제출하기")
        btn_submit.setStyleSheet("""
            background-color: #333; color: white; border-radius: 8px;
            padding: 12px; font-weight: bold;
        """)

        layout.addStretch()
        layout.addWidget(title)
        layout.addWidget(self.status_label)
        layout.addLayout(input_layout)
        layout.addWidget(btn_submit)
        layout.addStretch()

        self.form_widget.setLayout(layout)

    def create_input_btn(self, text):
        btn = QPushButton(text)
        btn.setFixedSize(90, 60)
        btn.setStyleSheet("""
            QPushButton {
                border: 2px solid #ddd;
                border-radius: 12px;
                background: white;
                font-size: 18px;
                color: #555;
            }
            QPushButton:hover { border-color: #66CCFF; }
        """)
        btn.clicked.connect(lambda: self.start_game_sequence(btn))
        return btn

    def start_game_sequence(self, btn):
        self.current_target = btn
        self.stack.setCurrentWidget(self.game_widget)
        self.game_widget.start_game()

    def back_to_form(self):
        self.stack.setCurrentWidget(self.form_widget)

    def show_status(self, msg):
        self.status_label.setText(msg)

    def finish_game(self, score):
        QTimer.singleShot(10, lambda: self._finish(score))

    def _finish(self, score):
        self.stack.setCurrentWidget(self.form_widget)

        if self.current_target:
            self.current_target.setText(str(score))
            self.current_target.setStyleSheet("""
                border: 2px solid #FF4444;
                border-radius: 12px;
                background: #FFF0F0;
                color: #FF4444;
                font-size: 20px;
                font-weight: bold;
            """)

        self.status_label.setText("입력 완료")
        self.status_label.setStyleSheet(
            "font-size: 16px; color: #FF4444; font-weight: bold;"
        )

if __name__ == "__main__":
    app = QApplication(sys.argv)
    window = MainWindow()
    window.show()
    sys.exit(app.exec_())

알고리즘 스터디 2주차 결산

sourceoftax — Sun, 5 Oct 2025 22:05:24 +0900

0927

#include <iostream>
#include <vector>
using namespace std;

int main() {
    long long min, max;
    cin >> min >> max;

    long long length = max - min + 1;
    vector<bool> isSquareFree(length, true);  

    for (long long i = 2; i * i <= max; i++) {
        long long square = i * i;

        long long start = (min + square - 1) / square * square;

        for (long long j = start; j <= max; j += square) {
            isSquareFree[j - min] = false; 
        }
    }

    int count = 0;
    for (int i = 0; i < length; i++) {
        if (isSquareFree[i]) count++;
    }

    cout << count << '\n';
    return 0;
}

0928

num = int(input())
d = [0] * (num + 1)

for x in range(2, num + 1):
    d[x] = d[x - 1] + 1         
    if x % 2 == 0:              
        d[x] = min(d[x], d[x // 2] + 1)
    if x % 3 == 0:              
        d[x] = min(d[x], d[x // 3] + 1)

print(d[num])

풀이과정: dp 알고리즘 중 상향식 dp를 사용하였다.

d[x]는 1로 만드는데 필요한 최소 연산 횟수로 설정하ㅗㄱ,

본인이 참고한 자료(블로그, 논문 등)가 있으면 꼭 출처를 남기시기 바랍니다.

참고 블로그: https://velog.io/@jxlhe46/알고리즘-다이나믹-프로그래밍

배운 점: 해당 문제를 풀며 새로 공부한 내용을 간략하게 작성하면 됩니다. (예시 : Gaussian Elimination을 응용해 역행렬을 계산하지 않고 LU분해를 하는 방법을 배웠다.)

0929

몸이 안좋아서 그냥 잠........

0930

num, caseNum = map(int, input().split())
d = {}

for _ in range(caseNum):
    s = input().strip()
    if s in d:
        del d[s]
    d[s] = True

for x in list(d.keys())[:num]:
    print(x)

풀이과정 : 단순하게 입력받은 당시 이미 해당 값이 존재하면 기존 값을 지운다. 반복문이 끝나면 제시된 수만큼 차례대로 출력한다

배운 점: 문제 자체는 간단하지만 시간 제한이 빡빡한 편이다. 처음에 일반적인 방식으로 in 연산과 remove 연산을 사용했더니 최악의 경우 O(n^2)가 나오기에 시간 초과에 걸렸다.

고치기 위해 dict를 사용했다. 다만 파이썬 버전이 낮으면 일반 dict가 순서를 기억하지 못하기에 주의가 필요하다

1001

#include <iostream>
#include <vector>
#include <tuple>
using namespace std;

int main(){
	int num(0), height(0), weight(0), score(1);
	vector <tuple<int, int, int>> arr;
	cin >> num;
	
	for(int i = 0; i < num; i++){
		cin >> weight >> height;
		arr.push_back({weight, height, score});
	}
	
	for(int i = 0; i < num; i++){
		for(int j = 0; j < num; j++){
			if(i==j) continue;
			
			 if (get<0>(arr[j]) > get<0>(arr[i]) &&
                get<1>(arr[j]) > get<1>(arr[i])) {
                get<2>(arr[i])++;
		}
		}
	}

	for (int i = 0; i < num; i++) {
	cout << get<2>(arr[i]) << " ";
	}

return 0;
}

풀이과정 : tuple을 통해 벡터에 세 개의 분류를 생성했다.

이후 반복문 연산을 통해 몸무게, 키가 모두 큰 경우에만 덩치가 크다고 판정한다. 이 경우 최악의 상황에서도 시간 복잡도는 O(n^2)이 된다. 문제의 시간 조건이 2초며 제한에 주어진 최대 수가 작은 편이기에 해당 방식을 사용했다

1002

num = int(input())
arr = [0]  

for _ in range(num):
    arr.append(int(input()))

d = [0] * (num + 1)

d[1] = arr[1]
if num >= 2:
    d[2] = arr[1] + arr[2]
if num >= 3:
    d[3] = max(arr[1] + arr[3], arr[2] + arr[3])

for i in range(4, num+1):
    d[i] = max(d[i-2] + arr[i], d[i-3] + arr[i-1] + arr[i])

print(d[num])

풀이과정 : d[i]는 i번째 계단까지 올라갔을 때 얻을 수 있는 최대 점수를 저장하는 배열이다

d[i]를 반복문 내에서 돌릴 때, 이전 계단에서 바로 올라오기 or 두 계단 뛰고 올라오기 중 더 큰 값을 골라 값에 집어 넣는다. 마지막에는 d[num]값을 출력한다.

배운 점: dp를 적용시키는 것에 익숙해지려 노력 중이

1003

#include <bits/stdc++.h>
using namespace std;

int main() {
    int N, M;
    cin >> N >> M;
    vector<string> grid(N);
    for (int i = 0; i < N; i++) cin >> grid[i];
    
    vector<vector<vector<int>>> visited(N, vector<vector<int>>(M, vector<int>(2, 0)));
    queue<tuple<int,int,int,int>> q;
    q.push({0, 0, 1, 0}); 
    visited[0][0][0] = 1;

    int dx[4] = {-1, 1, 0, 0};
    int dy[4] = {0, 0, -1, 1};

    while (!q.empty()) {
        auto [x, y, dist, broken] = q.front();
        q.pop();

        if (x == N-1 && y == M-1) {
            cout << dist << "\n";
            return 0;
        }

        for (int dir = 0; dir < 4; dir++) {
            int nx = x + dx[dir];
            int ny = y + dy[dir];

            if (nx < 0 || ny < 0 || nx >= N || ny >= M) continue;

            if (grid[nx][ny] == '0' && !visited[nx][ny][broken]) {
                visited[nx][ny][broken] = 1;
                q.push({nx, ny, dist + 1, broken});
            }

            if (grid[nx][ny] == '1' && broken == 0 && !visited[nx][ny][1]) {
                visited[nx][ny][1] = 1;
                q.push({nx, ny, dist + 1, 1});
            }
        }
    }

    cout << -1 << "\n";
    return 0;
}

풀이과정 : 기초 코드는 ppt 그대로

while문을 통해 bfs 탐색을 진행한다. 현재의 위치와 이동 거리, 벽이 부숴졌는지의 여부를 확인할 수 있다.

이후 if문을 통해서는 도착 여부를 확인한다. 만일 목표 지점에 도달하였다면 현재 dist 값을 출력한 다음에 종료한다. bfs를 이용하였기에, 처음 도착한 경우가 최단 거리가 된다

그 아래에 깔린 코드는 빈칸 이동/벽 부수고 이동에 관한 내용이다.

마지막으로 만일 도착점에 도달하지 못했다면 -1을 출력한다

참고 블로그: https://gmlwjd9405.github.io/2018/08/15/algorithm-bfs.html

배운 점: 지난 주 ppt에서 제공해주신 기초 코드를 토대로 풀이했다. bfs 관련 문제는 풀어보지 않았는데, 이번에 풀어보게 되어 좋았다.