7 Commits

Author SHA1 Message Date
09b7ea575b release: v2.2.1 (versionCode 9) 2026-11-05 12:40:58 +09:00
1d8ae8d4d9 GDPR: 설정에 광고 개인정보 설정(UMP 개인정보 옵션) 진입점 추가
UMP 가 privacyOptionsRequirementStatus=REQUIRED 로 판정한 사용자(유럽·영국 등)에게만
설정 화면에 '광고 개인정보 설정' 버튼을 보이고, 누르면 동의 양식을 다시 띄운다.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-05 12:40:49 +09:00
f363e89e3d AdMob 보상형·결과 카드 전용 광고 단위 적용 (모든 광고 실제 ID)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-05 12:33:50 +09:00
6b7b480816 광고 실패 시 배너·결과 카드 자리 접기, 실패 로그에 오류 코드
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-05 10:24:42 +09:00
697c1de4fe AdMob 실제 앱 ID·배너·전면 광고 단위 적용 (결과 카드는 배너 단위 공용, 보상형은 테스트 ID 유지)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-05 10:02:54 +09:00
2397dbfa4a release: v2.2.0 (versionCode 8) 2026-11-05 09:59:20 +09:00
c864b65ef4 수익화: 광고 간격 저장·보상형 광고·Play 결제·시즌 패스·꾸미기·미디에이션·초대 링크·결과 공유
앱
- 전면 광고: 판 수를 기기에 저장해 앱을 다시 켜도 이어 센다. 규칙은 "마지막 전면 뒤 3판 이상 + 세션 첫 판 제외"
- 보상형 광고: 30분 전면 끄기, TIME ATTACK 이어하기(1판 1회, 기록·리더보드 미반영), 리소 스킨·흑연 보드 해금
- Play Billing 9.1: remove_ads / supporter_pack(비소모) / season_pass(소모). 승인 즉시, 시즌 패스는 서버 적용 뒤 소비, 실행 때마다 복원
- 상점 탭: 시즌 패스 트랙, 블록 스킨 7종·보드 테마 5종, 배지 장착, 상품, 구매 복원
- 광고 제거 구매 시 배너·결과·전면 끔 (보상형은 선택지로 유지)
- AdMob 미디에이션 어댑터: AppLovin, Pangle
- 커스텀 방 초대 링크 https://tetrig.pages.dev/r/CODE (앱 링크) + 공유, 결과 카드 PNG 공유
- 로비·리더보드·프로필에 배지 표시

서버
- 0002_shop 마이그레이션: season_xp, user_items, purchases, users.badge
- 시즌 패스 XP(솔로 10/커스텀 20+10/리그 25+15), 30레벨 무료·프리미엄 트랙
- /api/pass, /api/purchase(Google Play Developer API 검증, PLAY_SA_KEY), /api/badge
- 게스트 병합·계정 삭제 시 패스·아이템·구매 이전/삭제

웹
- /r/<코드> 초대 안내 페이지, scripts/build-pages.sh, 개인정보처리방침·스토어 문구 갱신

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-05 09:58:10 +09:00
41 changed files with 2371 additions and 99 deletions

View File

@@ -180,9 +180,11 @@ scripts/release.sh patch # 또는 minor / major
`index.html` 기반 PWA 는 그대로 유지한다 (아이폰 사용자용 / 데모).
`dist/privacy.html` 은 개인정보처리방침이고 `/privacy` 로 서빙된다.
`/r/<코드>` 는 커스텀 방 초대 링크 안내 페이지(`store/room.html`)다. 앱이 있으면 앱 링크로 바로 그 방에 들어가고,
없으면 Play 스토어로 보낸다. 앱 링크 검증 파일은 `.well-known/assetlinks.json`.
```bash
node build.js
scripts/build-pages.sh # node build.js + dist/ 조립
wrangler pages deploy dist --project-name tetrig --branch main
```

View File

@@ -45,6 +45,10 @@ kotlin {
implementation(libs.okhttp)
implementation(libs.play.services.ads)
implementation(libs.ump)
implementation(libs.billing)
// AdMob 미디에이션: AdMob 콘솔에서 미디에이션 그룹을 만들어야 실제로 입찰에 들어온다.
implementation(libs.admob.applovin)
implementation(libs.admob.pangle)
}
}
}
@@ -66,6 +70,7 @@ android {
resValue("string", "admob_banner", prop("admobBanner", "ca-app-pub-3940256099942544/9214589741"))
resValue("string", "admob_card", prop("admobCard", "ca-app-pub-3940256099942544/6300978111"))
resValue("string", "admob_interstitial", prop("admobInterstitial", "ca-app-pub-3940256099942544/1033173712"))
resValue("string", "admob_rewarded", prop("admobRewarded", "ca-app-pub-3940256099942544/5224354917"))
}
sourceSets["main"].manifest.srcFile("src/androidMain/AndroidManifest.xml")

View File

@@ -38,6 +38,24 @@
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
<!-- 커스텀 방 초대 링크 https://tetrig.pages.dev/r/CODE (assetlinks.json 으로 검증) -->
<intent-filter android:autoVerify="true">
<action android:name="android.intent.action.VIEW" />
<category android:name="android.intent.category.DEFAULT" />
<category android:name="android.intent.category.BROWSABLE" />
<data android:scheme="https" android:host="tetrig.pages.dev" android:pathPrefix="/r/" />
</intent-filter>
</activity>
<!-- 결과 이미지 공유용 (cache/share 만 노출) -->
<provider
android:name="androidx.core.content.FileProvider"
android:authorities="${applicationId}.share"
android:exported="false"
android:grantUriPermissions="true">
<meta-data
android:name="android.support.FILE_PROVIDER_PATHS"
android:resource="@xml/share_paths" />
</provider>
</application>
</manifest>

View File

@@ -1,12 +1,16 @@
package kr.tkrmagid.tetrig
import android.app.Application
import android.content.Intent
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import kr.tkrmagid.tetrig.ads.AdsAndroid
import kr.tkrmagid.tetrig.data.AndroidStoreHolder
import kr.tkrmagid.tetrig.share.DeepLink
import kr.tkrmagid.tetrig.share.ShareAndroid
import kr.tkrmagid.tetrig.shop.PlayBilling
import kr.tkrmagid.tetrig.ui.App
class TetrigApp : Application() {
@@ -21,7 +25,22 @@ class MainActivity : ComponentActivity() {
enableEdgeToEdge()
super.onCreate(savedInstanceState)
AndroidStoreHolder.init(this)
ShareAndroid.activity = this
AdsAndroid.start(this)
PlayBilling.start(this)
if (savedInstanceState == null) handleLink(intent)
setContent { App() }
}
// launchMode=singleTop: 앱이 떠 있을 때 초대 링크를 누르면 여기로 온다.
override fun onNewIntent(intent: Intent) {
super.onNewIntent(intent)
setIntent(intent)
handleLink(intent)
}
private fun handleLink(intent: Intent?) {
if (intent?.action != Intent.ACTION_VIEW) return
DeepLink.roomFromPath(intent.data?.path)?.let { DeepLink.pendingRoom = it }
}
}

View File

@@ -10,6 +10,7 @@ import androidx.compose.foundation.layout.height
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.platform.LocalConfiguration
@@ -27,7 +28,10 @@ import com.google.android.gms.ads.interstitial.InterstitialAdLoadCallback
import com.google.android.ump.ConsentInformation
import com.google.android.ump.ConsentRequestParameters
import com.google.android.ump.UserMessagingPlatform
import com.google.android.gms.ads.rewarded.RewardedAd
import com.google.android.gms.ads.rewarded.RewardedAdLoadCallback
import kr.tkrmagid.tetrig.R
import kr.tkrmagid.tetrig.shop.Entitlements
import java.util.concurrent.atomic.AtomicBoolean
private const val TAG = "TetrigAds"
@@ -40,6 +44,14 @@ object AdsAndroid {
var ready by mutableStateOf(false)
private set
private var interstitial: InterstitialAd? = null
private var rewarded: RewardedAd? = null
/** 보상형 광고가 로드돼 있는지 (Compose 가 관찰). */
var rewardedReady by mutableStateOf(false)
private set
private var rewardedLoading = false
/** GDPR 지역 등에서 동의를 다시 고칠 수 있는 진입점이 필요한지 (Compose 가 관찰). */
var privacyRequired by mutableStateOf(false)
private set
/**
* UMP 동의(유럽·영국 등 필요한 지역에서만 팝업) → MobileAds 초기화 → 전면 광고 선로드.
@@ -53,6 +65,7 @@ object AdsAndroid {
{
UserMessagingPlatform.loadAndShowConsentFormIfRequired(act) { err ->
if (err != null) Log.w(TAG, "consent form: ${err.message}")
updatePrivacyRequired(consent)
if (consent.canRequestAds()) init(act)
}
},
@@ -61,18 +74,37 @@ object AdsAndroid {
if (consent.canRequestAds()) init(act)
}
private fun updatePrivacyRequired(consent: ConsentInformation) {
privacyRequired = consent.privacyOptionsRequirementStatus ==
ConsentInformation.PrivacyOptionsRequirementStatus.REQUIRED
Log.i(TAG, "consent status=${consent.consentStatus} privacyOptions=${consent.privacyOptionsRequirementStatus}")
}
/** 설정 화면의 "광고 개인정보 설정": 동의 양식을 다시 띄워 선택을 바꿀 수 있게 한다. */
fun showPrivacyOptions() {
val act = activity ?: return
UserMessagingPlatform.showPrivacyOptionsForm(act) { err ->
if (err != null) Log.w(TAG, "privacy options: ${err.message}")
val consent = UserMessagingPlatform.getConsentInformation(act)
updatePrivacyRequired(consent)
if (consent.canRequestAds()) init(act)
}
}
private fun init(act: Activity) {
if (!started.compareAndSet(false, true)) return
MobileAds.initialize(act.applicationContext) {
ready = true
Log.i(TAG, "MobileAds ready")
loadInterstitial()
loadRewarded()
}
}
fun loadInterstitial() {
val act = activity ?: return
if (!ready || interstitial != null) return
// 광고 제거를 샀으면 전면은 더 받지 않는다 (보상형은 사용자가 고를 수 있게 남긴다).
if (!ready || interstitial != null || Entitlements.adsRemoved) return
InterstitialAd.load(act, act.getString(R.string.admob_interstitial), AdRequest.Builder().build(),
object : InterstitialAdLoadCallback() {
override fun onAdLoaded(ad: InterstitialAd) {
@@ -80,7 +112,7 @@ object AdsAndroid {
Log.i(TAG, "interstitial loaded")
}
override fun onAdFailedToLoad(e: LoadAdError) {
Log.w(TAG, "interstitial failed: ${e.message}")
Log.w(TAG, "interstitial failed code=${e.code}: ${e.message}")
}
})
}
@@ -109,13 +141,75 @@ object AdsAndroid {
Log.i(TAG, "interstitial show")
ad.show(act)
}
fun loadRewarded() {
val act = activity ?: return
if (!ready || rewarded != null || rewardedLoading) return
rewardedLoading = true
RewardedAd.load(act, act.getString(R.string.admob_rewarded), AdRequest.Builder().build(),
object : RewardedAdLoadCallback() {
override fun onAdLoaded(ad: RewardedAd) {
rewarded = ad
rewardedLoading = false
rewardedReady = true
Log.i(TAG, "rewarded loaded")
}
override fun onAdFailedToLoad(e: LoadAdError) {
rewardedLoading = false
Log.w(TAG, "rewarded failed code=${e.code}: ${e.message}")
}
})
}
/** 끝까지 봐서 onUserEarnedReward 가 불렸을 때만 earned = true. 결과는 광고가 닫힌 뒤 한 번 알린다. */
fun showRewarded(onResult: (Boolean) -> Unit) {
val act = activity
val ad = rewarded
if (act == null || ad == null) {
onResult(false)
loadRewarded()
return
}
rewarded = null
rewardedReady = false
var earned = false
ad.fullScreenContentCallback = object : FullScreenContentCallback() {
override fun onAdDismissedFullScreenContent() {
Log.i(TAG, "rewarded dismissed earned=$earned")
onResult(earned)
loadRewarded()
}
override fun onAdFailedToShowFullScreenContent(e: com.google.android.gms.ads.AdError) {
Log.w(TAG, "rewarded show failed: ${e.message}")
onResult(false)
loadRewarded()
}
}
Log.i(TAG, "rewarded show")
ad.show(act) { item ->
Log.i(TAG, "rewarded earned ${item.amount} ${item.type}")
earned = true
}
}
}
actual fun showInterstitial(then: () -> Unit) = AdsAndroid.show(then)
actual fun privacyOptionsRequired(): Boolean = AdsAndroid.privacyRequired
actual fun showPrivacyOptions() = AdsAndroid.showPrivacyOptions()
actual fun rewardedAvailable(): Boolean = AdsAndroid.rewardedReady
actual fun showRewarded(onResult: (earned: Boolean) -> Unit) = AdsAndroid.showRewarded(onResult)
@Composable
actual fun AdBanner(modifier: Modifier) {
if (Entitlements.adsRemoved) return
val widthDp = LocalConfiguration.current.screenWidthDp
// 광고를 못 받으면(계정 승인 전·no fill 등) 자리를 아예 없앤다.
var failed by remember { mutableStateOf(false) }
if (failed) return
if (!AdsAndroid.ready) {
Box(modifier.fillMaxWidth().height(50.dp))
return
@@ -128,7 +222,10 @@ actual fun AdBanner(modifier: Modifier) {
setAdSize(AdSize.getCurrentOrientationAnchoredAdaptiveBannerAdSize(ctx, widthDp))
adListener = object : AdListener() {
override fun onAdLoaded() { Log.i(TAG, "banner loaded") }
override fun onAdFailedToLoad(e: LoadAdError) { Log.w(TAG, "banner failed: ${e.message}") }
override fun onAdFailedToLoad(e: LoadAdError) {
Log.w(TAG, "banner failed code=${e.code}: ${e.message}")
failed = true
}
}
loadAd(AdRequest.Builder().build())
}
@@ -139,6 +236,10 @@ actual fun AdBanner(modifier: Modifier) {
@Composable
actual fun AdCard(modifier: Modifier) {
if (Entitlements.adsRemoved) return
// 실패하면 300×250 빈 상자를 남기지 않고 접는다.
var failed by remember { mutableStateOf(false) }
if (failed) return
if (!AdsAndroid.ready) {
Box(modifier.size(300.dp, 250.dp))
return
@@ -151,7 +252,10 @@ actual fun AdCard(modifier: Modifier) {
setAdSize(AdSize.MEDIUM_RECTANGLE)
adListener = object : AdListener() {
override fun onAdLoaded() { Log.i(TAG, "card loaded") }
override fun onAdFailedToLoad(e: LoadAdError) { Log.w(TAG, "card failed: ${e.message}") }
override fun onAdFailedToLoad(e: LoadAdError) {
Log.w(TAG, "card failed code=${e.code}: ${e.message}")
failed = true
}
}
loadAd(AdRequest.Builder().build())
}

View File

@@ -0,0 +1,114 @@
package kr.tkrmagid.tetrig.share
import android.annotation.SuppressLint
import android.app.Activity
import android.content.Intent
import android.graphics.Bitmap
import android.graphics.Canvas
import android.graphics.Paint
import android.graphics.Path
import android.graphics.Typeface
import android.util.Log
import androidx.core.content.FileProvider
import java.io.File
@SuppressLint("StaticFieldLeak")
object ShareAndroid {
var activity: Activity? = null
}
actual fun shareText(text: String) {
val act = ShareAndroid.activity ?: return
val send = Intent(Intent.ACTION_SEND).apply {
type = "text/plain"
putExtra(Intent.EXTRA_TEXT, text)
}
act.startActivity(Intent.createChooser(send, "공유"))
}
actual fun shareCard(card: ShareCard) {
val act = ShareAndroid.activity ?: return
runCatching {
val dir = File(act.cacheDir, "share").apply { mkdirs() }
val file = File(dir, "tetrig-result.png")
file.outputStream().use { renderCard(card).compress(Bitmap.CompressFormat.PNG, 100, it) }
val uri = FileProvider.getUriForFile(act, "${act.packageName}.share", file)
val send = Intent(Intent.ACTION_SEND).apply {
type = "image/png"
putExtra(Intent.EXTRA_STREAM, uri)
putExtra(Intent.EXTRA_TEXT, "TETRIG ${card.mode} ${card.headline}\n$PLAY_URL")
addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
}
act.startActivity(Intent.createChooser(send, "결과 공유"))
}.onFailure { Log.w("TetrigShare", "share failed", it) }
}
// NEOBRUTAL 팔레트 (명세서 §13)
private const val INK = 0xFF17161B.toInt()
private const val BONE = 0xFFEDE7DA.toInt()
private const val PAPER = 0xFFE1D9C7.toInt()
private const val SAFETY = 0xFFFF4E11.toInt()
private const val SUB = 0xFF6E6A5E.toInt()
/** 1080×1350 (인스타 세로 비율) 결과 카드. 플랫 도형 + 하드 섀도 + 우하단 챔퍼컷만 쓴다. */
internal fun renderCard(card: ShareCard): Bitmap {
val w = 1080
val h = 1350
val bmp = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888)
val c = Canvas(bmp)
c.drawColor(BONE)
val mono = Typeface.create(Typeface.MONOSPACE, Typeface.NORMAL)
val monoBold = Typeface.create(Typeface.MONOSPACE, Typeface.BOLD)
val disp = Typeface.create(Typeface.MONOSPACE, Typeface.BOLD_ITALIC)
fun paint(color: Int, size: Float, tf: Typeface = mono) = Paint(Paint.ANTI_ALIAS_FLAG).apply {
this.color = color; textSize = size; typeface = tf
}
val fill = Paint(Paint.ANTI_ALIAS_FLAG)
// 로고
val logoTet = paint(SAFETY, 112f, disp)
val logoRig = paint(INK, 112f, disp)
c.drawText("TET", 80f, 190f, logoTet)
c.drawText("RIG", 80f + logoTet.measureText("TET"), 190f, logoRig)
fill.color = INK
c.drawRect(80f, 215f, 520f, 245f, fill)
// 카드 (하드 섀도 → 본체 → 테두리)
val left = 80f
val top = 320f
val right = w - 80f
val bottom = 1130f
val cut = 70f
fun cardPath(dx: Float, dy: Float) = Path().apply {
moveTo(left + dx, top + dy)
lineTo(right + dx, top + dy)
lineTo(right + dx, bottom - cut + dy)
lineTo(right - cut + dx, bottom + dy)
lineTo(left + dx, bottom + dy)
close()
}
fill.color = INK
c.drawPath(cardPath(16f, 16f), fill)
fill.color = PAPER
c.drawPath(cardPath(0f, 0f), fill)
val stroke = Paint(Paint.ANTI_ALIAS_FLAG).apply { color = INK; style = Paint.Style.STROKE; strokeWidth = 8f }
c.drawPath(cardPath(0f, 0f), stroke)
fill.color = SAFETY
c.drawRect(left + 4f, top + 4f, left + 44f, bottom - 4f, fill)
val x = left + 90f
c.drawText(card.mode, x, top + 110f, paint(SUB, 52f, monoBold))
c.drawText(card.headline, x, top + 270f, paint(INK, 150f, disp))
var y = top + 400f
val label = paint(SUB, 44f)
val value = paint(INK, 56f, monoBold)
for ((k, v) in card.rows.take(5)) {
c.drawText(k, x, y, label)
c.drawText(v, right - 70f - value.measureText(v), y, value)
y += 92f
}
card.nickname?.let { c.drawText(it, 80f, 1230f, paint(INK, 48f, monoBold)) }
c.drawText("Google Play 에서 TETRIG 검색", 80f, 1295f, paint(SUB, 38f))
return bmp
}

View File

@@ -0,0 +1,151 @@
package kr.tkrmagid.tetrig.shop
import android.annotation.SuppressLint
import android.app.Activity
import android.os.Handler
import android.os.Looper
import android.util.Log
import com.android.billingclient.api.AcknowledgePurchaseParams
import com.android.billingclient.api.BillingClient
import com.android.billingclient.api.BillingClientStateListener
import com.android.billingclient.api.BillingFlowParams
import com.android.billingclient.api.BillingResult
import com.android.billingclient.api.ConsumeParams
import com.android.billingclient.api.PendingPurchasesParams
import com.android.billingclient.api.ProductDetails
import com.android.billingclient.api.Purchase
import com.android.billingclient.api.QueryProductDetailsParams
import com.android.billingclient.api.QueryPurchasesParams
private const val TAG = "TetrigBilling"
/**
* Google Play 결제. 상품 3개(광고 제거·서포터 팩·시즌 패스)는 모두 "인앱 상품(일회성)"이다.
* - 결제가 끝나면 바로 승인(acknowledge)해 3일 뒤 자동 환불을 막는다.
* - 시즌 패스(소모성)는 서버가 권한을 준 뒤에만 소비(consume)해, 서버가 죽어 있어도 결제가 사라지지 않는다.
* - 앱을 켤 때마다 구매 내역을 다시 읽어 복원한다 (재설치·다른 기기 포함).
*/
@SuppressLint("StaticFieldLeak")
object PlayBilling : BillingPort {
private var activity: Activity? = null
private var client: BillingClient? = null
private val details = mutableMapOf<String, ProductDetails>()
private val main = Handler(Looper.getMainLooper())
fun start(act: Activity) {
activity = act
Shop.port = this
if (client != null) return
val c = BillingClient.newBuilder(act.applicationContext)
.setListener { result, purchases -> main.post { onPurchasesUpdated(result, purchases) } }
.enablePendingPurchases(PendingPurchasesParams.newBuilder().enableOneTimeProducts().build())
.enableAutoServiceReconnection()
.build()
client = c
c.startConnection(object : BillingClientStateListener {
override fun onBillingSetupFinished(r: BillingResult) {
main.post {
Log.i(TAG, "setup ${r.responseCode} ${r.debugMessage}")
Shop.connected = r.responseCode == BillingClient.BillingResponseCode.OK
if (Shop.connected) {
queryProducts()
queryPurchases(silent = true)
}
}
}
override fun onBillingServiceDisconnected() {
main.post { Shop.connected = false }
}
})
}
private fun queryProducts() {
val c = client ?: return
val params = QueryProductDetailsParams.newBuilder().setProductList(
Products.all.map {
QueryProductDetailsParams.Product.newBuilder().setProductId(it).setProductType(BillingClient.ProductType.INAPP).build()
},
).build()
c.queryProductDetailsAsync(params) { r, result ->
main.post {
Log.i(TAG, "products ${r.responseCode} found=${result.productDetailsList.map { it.productId }} missing=${result.unfetchedProductList.size}")
for (d in result.productDetailsList) {
details[d.productId] = d
d.oneTimePurchaseOfferDetails?.formattedPrice?.let { Shop.prices[d.productId] = it }
}
}
}
}
private fun queryPurchases(silent: Boolean) {
val c = client ?: return
c.queryPurchasesAsync(QueryPurchasesParams.newBuilder().setProductType(BillingClient.ProductType.INAPP).build()) { r, list ->
main.post {
Log.i(TAG, "purchases ${r.responseCode} n=${list.size}")
list.forEach { handle(it) }
if (!silent) {
Shop.message = when {
r.responseCode != BillingClient.BillingResponseCode.OK -> "구매 내역을 불러오지 못했습니다 (${r.responseCode})"
list.none { it.purchaseState == Purchase.PurchaseState.PURCHASED } -> "복원할 구매 내역이 없습니다"
else -> "구매 내역을 복원했습니다"
}
}
}
}
}
override fun restore() {
if (client?.isReady != true) {
Shop.message = "Play 스토어에 연결되지 않았습니다"
return
}
queryPurchases(silent = false)
}
override fun launch(productId: String) {
val act = activity
val c = client
val d = details[productId]
if (act == null || c == null || d == null) {
Shop.message = "상품 정보를 불러오지 못했습니다. 잠시 뒤 다시 시도해 주세요"
return
}
val pp = BillingFlowParams.ProductDetailsParams.newBuilder().setProductDetails(d).build()
val r = c.launchBillingFlow(act, BillingFlowParams.newBuilder().setProductDetailsParamsList(listOf(pp)).build())
if (r.responseCode != BillingClient.BillingResponseCode.OK) {
Shop.message = "결제 창을 열지 못했습니다 (${r.responseCode})"
}
}
private fun onPurchasesUpdated(r: BillingResult, purchases: List<Purchase>?) {
when (r.responseCode) {
BillingClient.BillingResponseCode.OK -> purchases?.forEach { handle(it) }
BillingClient.BillingResponseCode.USER_CANCELED -> Shop.message = null
BillingClient.BillingResponseCode.ITEM_ALREADY_OWNED -> queryPurchases(silent = false)
else -> Shop.message = "결제하지 못했습니다 (${r.responseCode})"
}
}
private fun handle(p: Purchase) {
when (p.purchaseState) {
Purchase.PurchaseState.PENDING -> Shop.message = "결제 대기 중입니다. 결제가 끝나면 자동으로 적용됩니다"
Purchase.PurchaseState.PURCHASED -> {
if (!p.isAcknowledged) {
client?.acknowledgePurchase(AcknowledgePurchaseParams.newBuilder().setPurchaseToken(p.purchaseToken).build()) { ar ->
Log.i(TAG, "ack ${p.products} ${ar.responseCode}")
}
}
for (id in p.products) Shop.onPurchased(id, p.purchaseToken)
Shop.message = null
}
else -> Unit
}
}
override fun consume(purchaseToken: String) {
client?.consumeAsync(ConsumeParams.newBuilder().setPurchaseToken(purchaseToken).build()) { r, _ ->
Log.i(TAG, "consume ${r.responseCode}")
}
}
}

View File

@@ -0,0 +1,4 @@
<?xml version="1.0" encoding="utf-8"?>
<paths>
<cache-path name="share" path="share/" />
</paths>

View File

@@ -2,12 +2,17 @@ package kr.tkrmagid.tetrig.ads
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import kr.tkrmagid.tetrig.data.Prefs
import kr.tkrmagid.tetrig.net.nowMs
import kr.tkrmagid.tetrig.shop.Entitlements
/**
* 광고 슬롯 (명세서 §10). 플레이 중 화면(솔로·대전 인게임)에는 절대 넣지 않는다.
* - AdBanner: 메인(탭바 위)·커스텀 로비 하단, 적응형 배너
* - AdCard: 모든 결과 화면, 300×250
* - 전면: 결과 확인 → 다음 행동 사이에만, 3판당 1회, 세션 첫 판 제외
* - 전면: 결과 확인 → 다음 행동 사이에만, 마지막 전면 뒤 3판 이상 + 세션 첫 판 제외
* - 보상형: 사용자가 직접 고를 때만 (30분 전면 끄기 · TIME ATTACK 이어하기 · 스킨 해금)
* 광고 제거(또는 서포터 팩)를 사면 배너·카드·전면은 모두 사라지고 보상형만 선택지로 남는다.
*/
@Composable
expect fun AdBanner(modifier: Modifier = Modifier)
@@ -15,25 +20,41 @@ expect fun AdBanner(modifier: Modifier = Modifier)
@Composable
expect fun AdCard(modifier: Modifier = Modifier)
/** 전면 광고 빈도 규칙. 플랫폼 구현은 showInterstitial 만 담당. */
/**
* 전면 광고 간격 규칙 (순수 함수).
*
* @param total 지금까지(앱을 껐다 켜도 이어서) 끝낸 판 수
* @param lastShownAt 마지막 전면 광고를 띄웠을 때의 total (없으면 0)
* @param session 이번 앱 실행에서 끝낸 판 수
*
* 예) 한 번에 2판씩 하는 사용자 → 4·8·12…번째 판, 3판씩 → 3·6·9…번째 판.
*/
fun interstitialDue(total: Int, lastShownAt: Int, session: Int): Boolean =
session >= 2 && total - lastShownAt >= AdPolicy.MIN_GAP
/** 전면 광고 빈도 규칙. 판 수는 기기에 저장해 앱을 다시 켜도 이어서 센다. */
object AdPolicy {
const val MIN_GAP = 3
const val AD_FREE_MS = 30 * 60_000L
/** 이번 세션(앱 실행)에서 끝낸 판 수. */
var gamesThisSession = 0
private set
private var shownAt = -1
const val EVERY = 3
val totalGames: Int get() = Prefs.str("ads.total", "0").toIntOrNull() ?: 0
private val lastShownAt: Int get() = Prefs.str("ads.lastShown", "0").toIntOrNull() ?: 0
fun onGameFinished() {
gamesThisSession++
Prefs.setStr("ads.total", (totalGames + 1).toString())
}
/** 3, 6, 9 … 판째 결과에서 다음 행동으로 넘어갈 때만. 첫 판은 자연히 제외된다. */
fun shouldShow(): Boolean =
gamesThisSession >= EVERY && gamesThisSession % EVERY == 0 && shownAt != gamesThisSession
fun shouldShow(now: Long = nowMs()): Boolean =
!Entitlements.adsRemoved && !Entitlements.adFreeActive(now) &&
interstitialDue(totalGames, lastShownAt, gamesThisSession)
fun markShown() {
shownAt = gamesThisSession
Prefs.setStr("ads.lastShown", totalGames.toString())
}
}
@@ -48,3 +69,18 @@ fun maybeInterstitial(then: () -> Unit) {
}
expect fun showInterstitial(then: () -> Unit)
/** 보상형 광고가 로드돼 바로 띄울 수 있는지 (Compose 가 관찰하는 상태를 읽는다). */
expect fun rewardedAvailable(): Boolean
/**
* 보상형 광고를 띄운다. 끝까지 봐서 보상 조건을 채웠을 때만 earned = true.
* 광고가 닫힌 뒤(또는 띄우지 못했을 때) 한 번 호출된다.
*/
expect fun showRewarded(onResult: (earned: Boolean) -> Unit)
/** 유럽·영국 등에서 광고 동의를 다시 고칠 수 있는 진입점을 보여야 하는지 (UMP 판정, Compose 가 관찰). */
expect fun privacyOptionsRequired(): Boolean
/** 광고 동의 양식(개인정보 옵션)을 다시 띄운다. */
expect fun showPrivacyOptions()

View File

@@ -58,6 +58,17 @@ class GameState(val mode: Mode, seed: Int, val versus: VersusHooks? = null) {
var lastEvent by mutableStateOf<String?>(null)
private set
/**
* TIME ATTACK 톱아웃 직후 "광고 보고 이어하기" 선택을 기다리는 중. 이 동안 시간은 멈춘다.
* canOfferContinue 가 false 면 (광고 미로드 등) 묻지 않고 바로 끝낸다.
*/
var awaitingContinue by mutableStateOf(false)
private set
/** 이어하기를 쓴 판. 기록·리더보드에 넣지 않는다. */
var continued by mutableStateOf(false)
private set
var canOfferContinue: () -> Boolean = { false }
/** UI 리컴포지션 트리거. 엔진 내부는 가변이라 버전 번호로 갱신을 알린다. */
var version by mutableIntStateOf(0)
private set
@@ -86,7 +97,7 @@ class GameState(val mode: Mode, seed: Int, val versus: VersusHooks? = null) {
}
fun tick(dtMs: Long) {
if (finished || paused) return
if (finished || paused || awaitingContinue) return
elapsedMs += dtMs
if (mode == Mode.TimeAttack && elapsedMs >= TIME_ATTACK_MS) {
@@ -155,7 +166,7 @@ class GameState(val mode: Mode, seed: Int, val versus: VersusHooks? = null) {
}
fun press(dir: Int) {
if (finished || paused) return
if (finished || paused || awaitingContinue) return
heldDir = dir
dasAcc = 0
arrAcc = 0
@@ -172,12 +183,12 @@ class GameState(val mode: Mode, seed: Int, val versus: VersusHooks? = null) {
}
fun rotate(dir: String) {
if (finished || paused) return
if (finished || paused || awaitingContinue) return
if (game.rotate(dir)) onMoveSucceeded()
}
fun hold() {
if (finished || paused) return
if (finished || paused || awaitingContinue) return
if (game.holdSwap()) {
gravityAcc = 0
lockAcc = 0
@@ -186,7 +197,7 @@ class GameState(val mode: Mode, seed: Int, val versus: VersusHooks? = null) {
}
fun hardDrop() {
if (finished || paused) return
if (finished || paused || awaitingContinue) return
val r = game.hardDrop(::beforeSpawn) ?: return
score += r.first * 2
applyLock(r.second)
@@ -225,13 +236,11 @@ class GameState(val mode: Mode, seed: Int, val versus: VersusHooks? = null) {
versus?.onTopOut()
} else if (mode == Mode.Endless) {
// 톱아웃해도 계속: 보드를 비우고 이어간다.
val keptScore = score
val keptLines = lines
game = TetrigGame((elapsedMs.toInt() xor score) or 1)
score = keptScore
lines = keptLines
lastEvent = "TOP OUT · 계속"
eventAcc = 0
freshBoard("TOP OUT · 계속")
} else if (mode == Mode.TimeAttack && !continued && canOfferContinue()) {
awaitingContinue = true
heldDir = 0
softHeld = false
} else {
finished = true
}
@@ -239,6 +248,32 @@ class GameState(val mode: Mode, seed: Int, val versus: VersusHooks? = null) {
bump()
}
/** 점수·라인·시간은 그대로 두고 보드만 새로 깐다. */
private fun freshBoard(event: String) {
game = TetrigGame((elapsedMs.toInt() xor score) or 1)
gravityAcc = 0
lockAcc = 0
lastEvent = event
eventAcc = 0
}
/** 보상형 광고를 끝까지 봤을 때: 남은 시간 그대로 빈 보드에서 이어간다 (1판 1회). */
fun acceptContinue() {
if (!awaitingContinue) return
awaitingContinue = false
continued = true
freshBoard("이어하기 · 기록 미반영")
bump()
}
/** 이어하기를 거절했거나 광고를 끝까지 보지 않았을 때. */
fun declineContinue() {
if (!awaitingContinue) return
awaitingContinue = false
finished = true
bump()
}
private fun describe(res: LockResult): String {
val name = when {
res.tspin == "tspin" -> "T-SPIN " + countName(res.lines)

View File

@@ -39,7 +39,7 @@ private const val PING = "{\"t\":\"ping\"}"
data class RoomPlayer(
val id: String, val nick: String, val guest: Boolean, val wins: Int, val alive: Boolean, val inRound: Boolean,
val connected: Boolean, val rematch: Boolean, val tr: Int?, val rank: String?,
val connected: Boolean, val rematch: Boolean, val tr: Int?, val rank: String?, val badge: String? = null,
)
data class RoomRules(val garbageMul: Double = 1.0, val ft: Int = 0, val sameBag: Boolean = false, val overtime: Boolean = true)
@@ -286,7 +286,7 @@ class RoomClient(val kind: String, val roomId: String) {
RoomPlayer(
p.str("id") ?: "", p.str("nick") ?: "?", p.bool("guest") ?: false, p.int("wins") ?: 0,
p.bool("alive") ?: false, p.bool("inRound") ?: false, p.bool("connected") ?: false,
p.bool("rematch") ?: false, p.int("tr"), p.str("rank"),
p.bool("rematch") ?: false, p.int("tr"), p.str("rank"), p.str("badge"),
)
}
players.clear()

View File

@@ -16,6 +16,7 @@ import kotlinx.serialization.json.intOrNull
import kotlinx.serialization.json.jsonObject
import kotlinx.serialization.json.longOrNull
import kr.tkrmagid.tetrig.data.Prefs
import kr.tkrmagid.tetrig.shop.Loadout
/** 화면 수명과 무관하게 끝까지 돌아야 하는 작업용 (기록 업로드 등). */
val AppScope = kotlinx.coroutines.CoroutineScope(kotlinx.coroutines.SupervisorJob() + kotlinx.coroutines.Dispatchers.Main)
@@ -54,7 +55,7 @@ class ApiResult(val code: Int, val data: JsonObject) {
val error: String get() = data.str("error") ?: if (code == 0) "서버에 연결할 수 없습니다" else "오류 ($code)"
}
data class User(val id: String, val nickname: String, val guest: Boolean, val email: String?)
data class User(val id: String, val nickname: String, val guest: Boolean, val email: String?, val badge: String? = null)
data class League(
val placed: Boolean, val placement: Int, val tr: Int?, val rank: String?, val games: Int, val wins: Int,
@@ -87,7 +88,7 @@ object Session {
}
private fun parseUser(u: JsonObject) =
User(u.str("id") ?: "", u.str("nickname") ?: "?", u.bool("guest") ?: true, u.str("email"))
User(u.str("id") ?: "", u.str("nickname") ?: "?", u.bool("guest") ?: true, u.str("email"), u.str("badge"))
/** 앱 시작 시: 토큰이 없거나 만료면 게스트 발급, 그다음 프로필 갱신. */
suspend fun ensure(): Boolean {
@@ -130,6 +131,9 @@ object Session {
l.int("games") ?: 0, l.int("wins") ?: 0,
)
}
(r.data["items"] as? JsonArray)?.let { a ->
Loadout.adoptServer(a.mapNotNull { (it as? JsonPrimitive)?.takeIf { p -> p.isString }?.content })
}
r.data.obj("season")?.let { s ->
seasonN = s.int("n") ?: 1
seasonEndsAt = s.long("endsAt") ?: 0L
@@ -164,6 +168,7 @@ object Session {
user = null
league = null
profile = null
Loadout.adoptServer(emptyList())
ensure()
}
@@ -188,4 +193,18 @@ object Session {
if (token == null || value <= 0) return
call("POST", "/api/solo", jsonOf("mode" to mode, "value" to value))
}
/** 기록에는 안 남기고 시즌 패스 XP 만 받는다 (이어하기를 쓴 판). */
suspend fun submitXpOnly(mode: String) {
if (token == null) return
call("POST", "/api/solo", jsonOf("mode" to mode, "xpOnly" to true))
}
/** 배지 장착 (null = 해제). */
suspend fun equipBadge(id: String?): String? {
val r = call("POST", "/api/badge", jsonOf("badge" to id))
if (!r.ok) return r.error
adopt(r)
return null
}
}

View File

@@ -0,0 +1,39 @@
package kr.tkrmagid.tetrig.share
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
/** 결과 공유 이미지에 들어갈 내용. 플랫폼이 NEOBRUTAL 카드 한 장(PNG)으로 그린다. */
data class ShareCard(
/** 예: "SPRINT", "리그전" */
val mode: String,
/** 큰 글씨 한 줄. 예: "1:02.34", "승리!" */
val headline: String,
val rows: List<Pair<String, String>>,
val nickname: String?,
)
/** 초대 링크 (앱 링크: 앱이 있으면 바로 그 방으로, 없으면 안내 페이지 → Play 스토어). */
fun roomInviteUrl(code: String) = "https://tetrig.pages.dev/r/$code"
fun roomInviteText(code: String) =
"TETRIG 커스텀 방에 초대합니다! 코드 $code\n${roomInviteUrl(code)}"
const val PLAY_URL = "https://play.google.com/store/apps/details?id=kr.tkrmagid.tetrig"
/** 시스템 공유 창으로 텍스트를 보낸다. */
expect fun shareText(text: String)
/** 결과 카드를 PNG 로 그려 시스템 공유 창으로 보낸다. */
expect fun shareCard(card: ShareCard)
/** 앱 링크(https://tetrig.pages.dev/r/CODE)로 들어온 방 코드. App 이 보고 방으로 보낸다. */
object DeepLink {
var pendingRoom: String? by mutableStateOf(null)
private val re = Regex("^/r/([A-Za-z0-9]{6})/?$")
/** URL 경로에서 방 코드를 꺼낸다. 형식이 틀리면 null. */
fun roomFromPath(path: String?): String? = path?.let { re.find(it)?.groupValues?.get(1)?.uppercase() }
}

View File

@@ -0,0 +1,126 @@
package kr.tkrmagid.tetrig.shop
import androidx.compose.ui.graphics.Color
import kr.tkrmagid.tetrig.ui.Palette
import kr.tkrmagid.tetrig.ui.pieceColor
/**
* 꾸미기 아이템 목록. 아이템 ID 는 "종류:이름" (서버 user_items.item 과 같은 형식).
* 색은 명세서 §13 NEOBRUTAL 규칙을 지킨다: 플랫 컬러만, 그라디언트·네온·블러 없음,
* 다크 네이비 배경 금지.
*/
enum class BlockStyle { Solid, Inset, Outline, Chamfer, Plate }
data class BlockSkin(
val id: String,
val name: String,
val colors: Map<Char, Color>,
val style: BlockStyle,
val unlock: Unlock,
) {
val item get() = "skin:$id"
fun color(type: Char): Color = colors[type] ?: Color(0xFF46464F)
}
data class BoardTheme(
val id: String,
val name: String,
val bg: Color,
val grid: Color?,
val panel: Color,
val unlock: Unlock,
) {
val item get() = "board:$id"
}
/** 아이템을 얻는 방법 (상점 화면 안내용). */
sealed interface Unlock {
data object Free : Unlock
/** 보상형 광고 1회 시청으로 영구 해금. */
data object Rewarded : Unlock
/** 서포터 팩 전용. */
data object Supporter : Unlock
/** 시즌 패스 레벨 보상. premium = 패스 구매자 트랙. */
data class Pass(val level: Int, val premium: Boolean) : Unlock
}
private fun palette(i: Long, o: Long, t: Long, s: Long, z: Long, j: Long, l: Long) = mapOf(
'I' to Color(i), 'O' to Color(o), 'T' to Color(t), 'S' to Color(s), 'Z' to Color(z), 'J' to Color(j), 'L' to Color(l),
'G' to Color(0xFF46464F),
)
private val classicColors = "IOTSZJLG".associateWith { pieceColor(it) }
object Catalog {
val skins = listOf(
BlockSkin("classic", "클래식", classicColors, BlockStyle.Solid, Unlock.Free),
BlockSkin(
"riso", "리소",
palette(0xFF5EC8E5, 0xFFFFE800, 0xFF765BA7, 0xFF00A95C, 0xFFFF665E, 0xFF0078BF, 0xFFFF6C2F),
BlockStyle.Solid, Unlock.Rewarded,
),
BlockSkin(
"chalk", "분필",
palette(0xFF9ED9D3, 0xFFF2DC8D, 0xFFC9B0F0, 0xFFB5DB97, 0xFFF0A49B, 0xFF9FB5EE, 0xFFF2BE8F),
BlockStyle.Inset, Unlock.Pass(5, premium = false),
),
BlockSkin("outline", "외곽선", classicColors, BlockStyle.Outline, Unlock.Pass(8, premium = true)),
BlockSkin(
"signal", "시그널",
palette(0xFF3E8BF2, 0xFFF5C531, 0xFFFF4E11, 0xFFEDE7DA, 0xFFD93A6A, 0xFF2B3FE0, 0xFFF2A03D),
BlockStyle.Chamfer, Unlock.Pass(15, premium = true),
),
BlockSkin(
"mono", "모노",
palette(0xFFEDE7DA, 0xFFD4CDBF, 0xFFFF4E11, 0xFFB8B1A3, 0xFF9C9588, 0xFF807A6E, 0xFFE1D9C7),
BlockStyle.Inset, Unlock.Pass(20, premium = false),
),
BlockSkin("supporter", "서포터", classicColors, BlockStyle.Plate, Unlock.Supporter),
)
val boards = listOf(
BoardTheme("ink", "잉크", Palette.Dwell, Palette.DGrid, Palette.DPanel, Unlock.Free),
BoardTheme("graphite", "흑연", Color(0xFF1B1A18), Color(0xFF2C2A27), Color(0xFF262420), Unlock.Rewarded),
BoardTheme("oxide", "산화철", Color(0xFF1A1210), Color(0xFF33241F), Color(0xFF2A1D19), Unlock.Pass(1, premium = true)),
BoardTheme("nogrid", "무격자", Palette.Dwell, null, Palette.DPanel, Unlock.Pass(12, premium = false)),
BoardTheme("moss", "이끼", Color(0xFF12150F), Color(0xFF242A1E), Color(0xFF1E2219), Unlock.Pass(22, premium = true)),
)
val defaultSkin get() = skins.first()
val defaultBoard get() = boards.first()
fun skin(id: String): BlockSkin? = skins.firstOrNull { it.id == id }
fun board(id: String): BoardTheme? = boards.firstOrNull { it.id == id }
/** 서버/클라이언트 공용 아이템 ID → 화면 이름. */
fun itemName(item: String): String {
val (kind, id) = item.split(':', limit = 2).let { it[0] to it.getOrElse(1) { "" } }
return when (kind) {
"skin" -> "블록 스킨 · " + (skin(id)?.name ?: id)
"board" -> "보드 테마 · " + (board(id)?.name ?: id)
"badge" -> "배지 · " + badgeName(id)
else -> item
}
}
/** 배지 표시 이름. 시즌 배지는 s{n}_finish / s{n}_pass / s{n}_elite. */
fun badgeName(id: String): String {
if (id == "supporter") return "SUPPORTER"
val m = Regex("^s(\\d+)_(finish|pass|elite)$").find(id) ?: return id.uppercase()
val n = m.groupValues[1]
return when (m.groupValues[2]) {
"finish" -> "S$n 완주"
"pass" -> "S$n 패스"
else -> "S$n 엘리트"
}
}
fun badgeColor(id: String): Color = when {
id == "supporter" -> Palette.Amber
id.endsWith("_elite") -> Palette.Safety
id.endsWith("_pass") -> Palette.Violet
else -> Palette.Cobalt
}
fun badgeText(id: String): Color = if (id == "supporter") Palette.Ink else Palette.Bone
}

View File

@@ -0,0 +1,58 @@
package kr.tkrmagid.tetrig.shop
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import kr.tkrmagid.tetrig.net.Session
import kr.tkrmagid.tetrig.net.arr
import kr.tkrmagid.tetrig.net.bool
import kr.tkrmagid.tetrig.net.int
import kr.tkrmagid.tetrig.net.long
import kr.tkrmagid.tetrig.net.str
data class PassTier(val level: Int, val free: String?, val premium: String?)
data class PassState(
val season: Int,
val endsAt: Long,
val xp: Int,
val level: Int,
val maxLevel: Int,
val xpPerLevel: Int,
val premium: Boolean,
/** 서버가 Play 결제를 검증할 수 있을 때만 true. false 면 구매 버튼을 숨긴다. */
val purchasable: Boolean,
val tiers: List<PassTier>,
) {
/** 현재 레벨 안에서 모은 XP (0 until xpPerLevel). 만렙이면 xpPerLevel. */
val xpInLevel: Int get() = if (level >= maxLevel) xpPerLevel else xp - (level - 1) * xpPerLevel
}
/** 시즌 패스 (서버가 정본). 리그 시즌과 같은 주기(2개월)로 돈다. */
object SeasonPass {
var state by mutableStateOf<PassState?>(null)
private set
var error by mutableStateOf<String?>(null)
private set
suspend fun load() {
val r = Session.call("GET", "/api/pass")
if (!r.ok) {
error = r.error
return
}
error = null
val d = r.data
state = PassState(
season = d.int("season") ?: 1,
endsAt = d.long("endsAt") ?: 0L,
xp = d.int("xp") ?: 0,
level = d.int("level") ?: 1,
maxLevel = d.int("maxLevel") ?: 30,
xpPerLevel = d.int("xpPerLevel") ?: 100,
premium = d.bool("premium") ?: false,
purchasable = d.bool("purchasable") ?: false,
tiers = d.arr("tiers").map { PassTier(it.int("level") ?: 0, it.str("free"), it.str("premium")) },
)
}
}

View File

@@ -0,0 +1,190 @@
package kr.tkrmagid.tetrig.shop
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateMapOf
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import kotlinx.coroutines.launch
import kotlinx.serialization.json.JsonArray
import kotlinx.serialization.json.JsonObject
import kotlinx.serialization.json.JsonPrimitive
import kotlinx.serialization.json.jsonArray
import kotlinx.serialization.json.jsonObject
import kr.tkrmagid.tetrig.ads.AdPolicy
import kr.tkrmagid.tetrig.data.Prefs
import kr.tkrmagid.tetrig.net.AppScope
import kr.tkrmagid.tetrig.net.JsonCodec
import kr.tkrmagid.tetrig.net.Session
import kr.tkrmagid.tetrig.net.bool
import kr.tkrmagid.tetrig.net.jsonOf
import kr.tkrmagid.tetrig.net.nowMs
import kr.tkrmagid.tetrig.net.str
/** Play 인앱 상품 ID. Play Console 의 "인앱 상품" 에 같은 ID 로 만들어야 한다. */
object Products {
const val REMOVE_ADS = "remove_ads" // 비소모성 3,300원
const val SUPPORTER = "supporter_pack" // 비소모성 5,900원 (광고 제거 + 서포터 스킨·배지)
const val SEASON_PASS = "season_pass" // 소모성 4,900원 (시즌마다 다시 산다)
val all = listOf(REMOVE_ADS, SUPPORTER, SEASON_PASS)
/** Play 에서 가격을 못 받았을 때 보여 줄 기준가. */
fun listPrice(id: String) = when (id) {
REMOVE_ADS -> "3,300원"
SUPPORTER -> "5,900원"
else -> "4,900원"
}
}
/** 기기에 저장되는 권한(구매·보상). 서버 없이도 동작해야 하는 것만 여기 둔다. */
object Entitlements {
fun owns(productId: String): Boolean = Prefs.flag("own.$productId", false)
val adsRemoved: Boolean get() = owns(Products.REMOVE_ADS) || owns(Products.SUPPORTER)
val adFreeUntil: Long get() = Prefs.str("ads.freeUntil", "0").toLongOrNull() ?: 0L
fun adFreeActive(now: Long = nowMs()): Boolean = adFreeUntil > now
/** 보상형 광고 보상: 지금부터 30분간 전면 광고 끄기 (이미 켜져 있으면 연장하지 않고 새로 30분). */
fun grantAdFree(now: Long = nowMs()) = Prefs.setStr("ads.freeUntil", (now + AdPolicy.AD_FREE_MS).toString())
/** 기기에서 해금한 꾸미기 아이템 (보상형 광고, 서포터 팩). */
fun hasLocalItem(item: String): Boolean = Prefs.flag("item.$item", false)
fun grantLocalItem(item: String) = Prefs.setFlag("item.$item", true)
internal fun grantProduct(productId: String) {
Prefs.setFlag("own.$productId", true)
if (productId == Products.SUPPORTER) grantLocalItem("skin:supporter")
}
}
/** 장착 상태 + 보유 판정. */
object Loadout {
/** 서버가 알려준 보유 아이템 (시즌 패스 보상, 검증된 구매). */
val serverItems = mutableStateMapOf<String, Boolean>()
fun owns(item: String): Boolean {
val (kind, id) = item.split(':', limit = 2).let { it[0] to it.getOrElse(1) { "" } }
val unlock = when (kind) {
"skin" -> Catalog.skin(id)?.unlock
"board" -> Catalog.board(id)?.unlock
else -> null
}
if (unlock == Unlock.Free) return true
return Entitlements.hasLocalItem(item) || serverItems[item] == true
}
val skin: BlockSkin
get() = Catalog.skin(Prefs.str("equip.skin", "classic"))?.takeIf { owns(it.item) } ?: Catalog.defaultSkin
val board: BoardTheme
get() = Catalog.board(Prefs.str("equip.board", "ink"))?.takeIf { owns(it.item) } ?: Catalog.defaultBoard
fun equipSkin(id: String) = Prefs.setStr("equip.skin", id)
fun equipBoard(id: String) = Prefs.setStr("equip.board", id)
fun adoptServer(items: List<String>) {
serverItems.clear()
items.forEach { serverItems[it] = true }
}
}
/** 플랫폼 결제 (Android: Play Billing). */
interface BillingPort {
fun launch(productId: String)
fun consume(purchaseToken: String)
fun restore()
}
/** 결제 상태 + 서버 동기화. Compose 가 관찰한다. */
object Shop {
var port: BillingPort? = null
/** 상품 ID → Play 가 준 현지 가격 문자열. 비어 있으면 Play 에 상품이 아직 없다. */
val prices = mutableStateMapOf<String, String>()
var connected by mutableStateOf(false)
var message by mutableStateOf<String?>(null)
/** 서버 확인을 기다리는 시즌 패스 구매가 있는지. */
var passPending by mutableStateOf(false)
private set
fun buy(productId: String) {
val p = port
if (p == null || !connected) {
message = "Play 스토어에 연결되지 않았습니다. Play 스토어에서 설치한 앱에서만 구매할 수 있습니다"
return
}
if (prices[productId] == null) {
message = "아직 판매 준비 중인 상품입니다"
return
}
message = null
p.launch(productId)
}
fun restore() {
val p = port ?: run { message = "Play 스토어에 연결되지 않았습니다"; return }
message = "구매 내역을 확인하는 중…"
p.restore()
}
/**
* 플랫폼이 "결제 완료" 를 알릴 때 (새 구매·복원 모두). 승인(acknowledge)은 플랫폼이 이미 했다.
* 기기 권한은 바로 주고, 서버 권한(배지·패스)은 서버 검증 뒤에 붙는다.
*/
fun onPurchased(productId: String, purchaseToken: String) {
if (productId != Products.SEASON_PASS) Entitlements.grantProduct(productId)
// 비소모성은 복원 때마다 다시 들어온다. 지금 계정으로 이미 서버에 알린 구매면 건너뛴다.
if (productId != Products.SEASON_PASS && Prefs.flag(syncedKey(purchaseToken), false)) return
addPending(productId, purchaseToken)
AppScope.launch { syncPending() }
}
private fun syncedKey(token: String) = "synced.${Session.user?.id ?: "-"}.${token.take(48)}"
// ── 서버 동기화 대기열 (앱을 껐다 켜도 남는다) ──
private fun pending(): List<Pair<String, String>> = runCatching {
JsonCodec.parseToJsonElement(Prefs.str("shop.pending", "[]")).jsonArray.map {
val o = it.jsonObject
(o.str("p") ?: "") to (o.str("t") ?: "")
}.filter { it.first.isNotBlank() && it.second.isNotBlank() }
}.getOrDefault(emptyList())
private fun savePending(list: List<Pair<String, String>>) {
val arr = JsonArray(list.map { (p, t) -> JsonObject(mapOf("p" to JsonPrimitive(p), "t" to JsonPrimitive(t))) })
Prefs.setStr("shop.pending", arr.toString())
passPending = list.any { it.first == Products.SEASON_PASS }
}
private fun addPending(productId: String, token: String) {
val list = pending()
if (list.none { it.second == token }) savePending(list + (productId to token))
}
private var syncing = false
/** 서버에 구매를 알려 배지·시즌 패스를 받는다. 실패하면 다음 앱 실행 때 다시 시도. */
suspend fun syncPending() {
if (syncing || Session.token == null) return
syncing = true
try {
var list = pending()
passPending = list.any { it.first == Products.SEASON_PASS }
for ((product, token) in list) {
val r = Session.call("POST", "/api/purchase", jsonOf("productId" to product, "purchaseToken" to token))
val done = r.ok || r.code == 400 || r.code == 409 || r.code == 410
if (r.ok && r.data.bool("consume") == true) port?.consume(token)
if (r.ok) Prefs.setFlag(syncedKey(token), true)
if (!r.ok && product == Products.SEASON_PASS && r.code != 0) message = r.error
if (done) {
list = list.filterNot { it.second == token }
savePending(list)
}
}
Session.refresh()
} finally {
syncing = false
}
}
}

View File

@@ -17,6 +17,9 @@ import androidx.compose.ui.Modifier
import kr.tkrmagid.tetrig.game.Mode
import kr.tkrmagid.tetrig.game.RoomClient
import kr.tkrmagid.tetrig.net.Session
import kr.tkrmagid.tetrig.net.bool
import kr.tkrmagid.tetrig.share.DeepLink
import kr.tkrmagid.tetrig.shop.Shop
val LocalLayout = staticCompositionLocalOf { layoutFor(androidx.compose.ui.unit.Dp(390f), androidx.compose.ui.unit.Dp(844f)) }
@@ -25,11 +28,12 @@ sealed interface Screen {
data object Settings : Screen
data object Profile : Screen
data object Leaderboard : Screen
data object Shop : Screen
data object CustomEntry : Screen
data object Queue : Screen
data class Room(val client: RoomClient) : Screen
data class Game(val mode: Mode, val seed: Int) : Screen
data class Result(val mode: Mode, val score: Int, val lines: Int, val timeMs: Long, val pps: Double) : Screen
data class Result(val mode: Mode, val score: Int, val lines: Int, val timeMs: Long, val pps: Double, val continued: Boolean = false) : Screen
}
@Composable
@@ -37,13 +41,30 @@ fun App() {
var screen by remember { mutableStateOf<Screen>(Screen.Main) }
// 첫 실행: 게스트 자동 발급 (가입 없이 즉시 플레이). 실패해도 솔로는 오프라인으로 된다.
LaunchedEffect(Unit) { Session.ensure() }
LaunchedEffect(Unit) {
if (Session.ensure()) Shop.syncPending()
}
// 초대 링크(https://tetrig.pages.dev/r/CODE)로 들어오면 방이 있는지 보고 바로 들어간다.
// 게임 중에 링크를 눌렀으면 그 판을 끊지 않고, 홈/메뉴 화면으로 돌아왔을 때 처리한다.
val pendingRoom = DeepLink.pendingRoom
val idle = screen !is Screen.Game && screen !is Screen.Room && screen !is Screen.Queue
LaunchedEffect(pendingRoom, idle) {
val code = pendingRoom ?: return@LaunchedEffect
if (!idle) return@LaunchedEffect
if (Session.token == null) Session.ensure()
val r = Session.call("GET", "/api/rooms/$code", withToken = false)
screen = if (r.ok && r.data.bool("exists") == true) Screen.Room(RoomClient("custom", code)) else Screen.CustomEntry
// 키가 바뀌면 이 코루틴이 취소되므로 링크 소비는 맨 마지막에 한다.
DeepLink.pendingRoom = null
}
val onTab: (Int) -> Unit = { i ->
screen = when (i) {
1 -> Screen.Leaderboard
2 -> Screen.Profile
3 -> Screen.Settings
3 -> Screen.Shop
4 -> Screen.Settings
else -> Screen.Main
}
}
@@ -72,6 +93,7 @@ fun App() {
is Screen.Settings -> SettingsScreen(onBack = { screen = Screen.Main }, onTab = onTab)
is Screen.Profile -> ProfileScreen(onTab = onTab)
is Screen.Leaderboard -> LeaderboardScreen(onTab = onTab)
is Screen.Shop -> ShopScreen(onTab = onTab)
is Screen.CustomEntry -> CustomEntryScreen(
onJoin = { code -> screen = Screen.Room(RoomClient("custom", code)) },
@@ -94,8 +116,8 @@ fun App() {
mode = s.mode,
seed = s.seed,
onExit = { screen = Screen.Main },
onFinish = { score, lines, timeMs, pps ->
screen = Screen.Result(s.mode, score, lines, timeMs, pps)
onFinish = { score, lines, timeMs, pps, continued ->
screen = Screen.Result(s.mode, score, lines, timeMs, pps, continued)
},
)
@@ -105,6 +127,7 @@ fun App() {
lines = s.lines,
timeMs = s.timeMs,
pps = s.pps,
continued = s.continued,
onRetry = { screen = Screen.Game(s.mode, randomSeed()) },
onHome = { screen = Screen.Main },
)

View File

@@ -18,7 +18,9 @@ import androidx.compose.foundation.layout.width
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.runtime.withFrameNanos
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
@@ -34,6 +36,10 @@ import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import kotlinx.coroutines.launch
import kr.tkrmagid.tetrig.ads.AdPolicy
import kr.tkrmagid.tetrig.ads.rewardedAvailable
import kr.tkrmagid.tetrig.ads.showRewarded
import kr.tkrmagid.tetrig.shop.BlockSkin
import kr.tkrmagid.tetrig.shop.Loadout
import kr.tkrmagid.tetrig.data.Prefs
import kr.tkrmagid.tetrig.net.AppScope
import kr.tkrmagid.tetrig.net.Session
@@ -47,9 +53,9 @@ fun GameScreen(
mode: Mode,
seed: Int,
onExit: () -> Unit,
onFinish: (score: Int, lines: Int, timeMs: Long, pps: Double) -> Unit,
onFinish: (score: Int, lines: Int, timeMs: Long, pps: Double, continued: Boolean) -> Unit,
) {
val state = remember(mode, seed) { GameState(mode, seed) }
val state = remember(mode, seed) { GameState(mode, seed).also { it.canOfferContinue = { rewardedAvailable() } } }
val l = LocalLayout.current
val ghostOn = remember { Prefs.flag("ghost", true) }
val lefty = remember { Prefs.flag("lefty", false) }
@@ -70,9 +76,15 @@ fun GameScreen(
}
}
// 광고를 보는 동안 앱이 백그라운드로 가도 프레임 루프는 awaitingContinue 로 멈춰 있다.
LaunchedEffect(state.finished) {
if (state.finished) {
when (mode) {
if (state.continued) {
// 이어하기를 쓴 판은 기록·리더보드에 넣지 않고 시즌 패스 XP 만 받는다.
AppScope.launch { Session.submitXpOnly(mode.id) }
} else when (mode) {
Mode.Sprint -> if (state.lines >= SPRINT_GOAL_LINES) {
Prefs.submitSprint(state.elapsedMs)
val ms = state.elapsedMs
@@ -85,7 +97,7 @@ fun GameScreen(
}
}
AdPolicy.onGameFinished()
onFinish(state.score, state.lines, state.elapsedMs, state.pps)
onFinish(state.score, state.lines, state.elapsedMs, state.pps, state.continued)
}
}
@@ -117,6 +129,47 @@ fun GameScreen(
if (state.paused) {
PauseOverlay(onResume = { state.paused = false }, onExit = onExit)
}
if (state.awaitingContinue) {
ContinueOverlay(state)
}
}
/** TIME ATTACK 톱아웃: 보상형 광고로 1회 이어하기. 조건과 보상을 시청 전에 알린다 (AdMob 정책). */
@Composable
private fun ContinueOverlay(state: GameState) {
val s = LocalLayout.current.uiScale
var watching by remember { mutableStateOf(false) }
Box(
Modifier.fillMaxSize().background(Color(0xCC17161B)),
contentAlignment = Alignment.Center,
) {
Column(Modifier.padding((24 * s).dp), horizontalAlignment = Alignment.CenterHorizontally) {
Disp("TOP OUT", color = Palette.Safety, size = (30 * s).sp)
Spacer(Modifier.height((10 * s).dp))
Mono("남은 시간 ${formatMs(state.remainingMs)} · 점수 ${state.score}", color = Palette.Bone, size = (14 * s).sp)
Spacer(Modifier.height((14 * s).dp))
Mono(
"광고를 끝까지 보면 빈 보드에서 점수와 남은 시간 그대로 이어서 할 수 있습니다 (1판 1회).\n이어한 판의 점수는 내 기록과 리더보드에 올라가지 않습니다.",
color = Palette.DSub, size = (12 * s).sp, align = TextAlign.Center, maxLines = 5,
)
Spacer(Modifier.height((20 * s).dp))
NeoPanel(background = Palette.Safety, onClick = {
if (watching) return@NeoPanel
watching = true
showRewarded { earned -> if (earned) state.acceptContinue() else state.declineContinue() }
}) {
Mono(
if (watching) "광고 불러오는 중…" else "▶ 광고 보고 이어하기",
Modifier.padding(horizontal = (26 * s).dp, vertical = (13 * s).dp),
size = (14 * s).sp, weight = FontWeight.Bold,
)
}
Spacer(Modifier.height((12 * s).dp))
NeoPanel(onClick = { if (!watching) state.declineContinue() }) {
Mono("결과 보기", Modifier.padding(horizontal = (26 * s).dp, vertical = (13 * s).dp), size = (14 * s).sp, weight = FontWeight.Bold)
}
}
}
}
// ── HUD ──────────────────────────────────────────────────────────
@@ -238,17 +291,21 @@ private fun BoardCanvas(state: GameState, ghostOn: Boolean) {
@Suppress("UNUSED_EXPRESSION")
state.version // 엔진 변경 시 재그리기
val game = state.game
val skin = remember { Loadout.skin }
val theme = remember { Loadout.board }
Canvas(Modifier.fillMaxSize()) {
val cw = size.width / Config.BOARD_W
val ch = size.height / Config.VISIBLE_H
drawRect(Palette.Dwell)
drawRect(theme.bg)
// 격자
for (x in 0..Config.BOARD_W) {
drawLine(Palette.DGrid, Offset(x * cw, 0f), Offset(x * cw, size.height), 1f)
}
for (y in 0..Config.VISIBLE_H) {
drawLine(Palette.DGrid, Offset(0f, y * ch), Offset(size.width, y * ch), 1f)
theme.grid?.let { grid ->
for (x in 0..Config.BOARD_W) {
drawLine(grid, Offset(x * cw, 0f), Offset(x * cw, size.height), 1f)
}
for (y in 0..Config.VISIBLE_H) {
drawLine(grid, Offset(0f, y * ch), Offset(size.width, y * ch), 1f)
}
}
fun cellRect(bx: Int, by: Int): Pair<Offset, Size>? {
@@ -258,15 +315,15 @@ private fun BoardCanvas(state: GameState, ghostOn: Boolean) {
return Offset(left + 1f, top + 1f) to Size(cw - 2f, ch - 2f)
}
fun block(bx: Int, by: Int, color: Color) {
fun block(bx: Int, by: Int, type: Char) {
val r = cellRect(bx, by) ?: return
drawRect(color, topLeft = r.first, size = r.second)
skinBlock(skin, type, r.first, r.second, theme.bg)
}
// 쌓인 블록
for (y in 0 until Config.VISIBLE_H) {
for (x in 0 until Config.BOARD_W) {
game.board[y][x]?.let { block(x, y, pieceColor(it)) }
game.board[y][x]?.let { block(x, y, it) }
}
}
@@ -286,7 +343,7 @@ private fun BoardCanvas(state: GameState, ghostOn: Boolean) {
// 현재 피스
if (!game.over) {
val t = game.active.type
for (c in game.cells()) block(c[0], c[1], pieceColor(t))
for (c in game.cells()) block(c[0], c[1], t)
}
}
}
@@ -300,7 +357,7 @@ private fun SidePanel(label: String, pieces: List<Char>, s: Float, slots: Int, t
Modifier
.fillMaxWidth()
.height(((if (tiny) 34 else 44) * s * slots).dp)
.background(Palette.DPanel),
.background(remember { Loadout.board.panel }),
) {
Column(Modifier.fillMaxSize().padding(4.dp)) {
repeat(slots) { i ->
@@ -315,7 +372,15 @@ private fun SidePanel(label: String, pieces: List<Char>, s: Float, slots: Int, t
@Composable
private fun MiniPiece(type: Char) {
Canvas(Modifier.fillMaxSize()) {
val skin = remember { Loadout.skin }
val panel = remember { Loadout.board.panel }
MiniPieceCanvas(type, skin, panel)
}
/** 피스 하나를 칸 안에 가운데 맞춰 그린다 (HOLD/NEXT, 상점 미리보기 공용). */
@Composable
internal fun MiniPieceCanvas(type: Char, skin: BlockSkin, bg: Color, modifier: Modifier = Modifier.fillMaxSize()) {
Canvas(modifier) {
val cells = kr.tkrmagid.tetrig.engine.STATES.getValue(type)[0]
val xs = cells.map { it[0] }
val ys = cells.map { it[1] }
@@ -326,15 +391,10 @@ private fun MiniPiece(type: Char) {
val c = minOf(size.width / (w + 0.6f), size.height / (h + 0.6f))
val ox = (size.width - c * w) / 2f
val oy = (size.height - c * h) / 2f
val color = pieceColor(type)
for (cell in cells) {
val gx = cell[0] - minX
val gy = maxY - cell[1]
drawRect(
color,
topLeft = Offset(ox + gx * c + 1f, oy + gy * c + 1f),
size = Size(c - 2f, c - 2f),
)
skinBlock(skin, type, Offset(ox + gx * c + 1f, oy + gy * c + 1f), Size(c - 2f, c - 2f), bg)
}
}
}

View File

@@ -33,10 +33,14 @@ import androidx.compose.ui.unit.sp
import kr.tkrmagid.tetrig.ads.AdBanner
import kr.tkrmagid.tetrig.ads.AdCard
import kr.tkrmagid.tetrig.ads.maybeInterstitial
import kr.tkrmagid.tetrig.ads.privacyOptionsRequired
import kr.tkrmagid.tetrig.ads.showPrivacyOptions
import kr.tkrmagid.tetrig.data.Prefs
import kr.tkrmagid.tetrig.net.Session
import kr.tkrmagid.tetrig.net.nowMs
import kr.tkrmagid.tetrig.game.Mode
import kr.tkrmagid.tetrig.share.ShareCard
import kr.tkrmagid.tetrig.share.shareCard
@Composable
fun MainScreen(
@@ -211,7 +215,7 @@ private fun HazardBar(scale: Float) {
@Composable
fun TabBar(selected: Int, scale: Float, onSelect: (Int) -> Unit) {
val items = listOf("홈", "리더보드", "프로필", "설정")
val items = listOf("홈", "리더보드", "프로필", "상점", "설정")
Row(
Modifier
.fillMaxWidth()
@@ -321,10 +325,12 @@ fun ResultScreen(
lines: Int,
timeMs: Long,
pps: Double,
continued: Boolean = false,
onRetry: () -> Unit,
onHome: () -> Unit,
) {
val s = LocalLayout.current.uiScale
val headline = if (mode == Mode.Sprint) formatMs(timeMs) else "$score"
Column(
Modifier.fillMaxSize().verticalScroll(rememberScrollState()).padding((20 * s).dp),
verticalArrangement = Arrangement.Center,
@@ -340,9 +346,26 @@ fun ResultScreen(
StatRow("라인", "$lines", s)
StatRow("시간", formatMs(timeMs), s)
StatRow("PPS", ((pps * 100).toInt() / 100.0).toString(), s)
if (continued) {
Spacer(Modifier.height(6.dp))
Mono("이어하기를 쓴 판이라 기록·리더보드에 반영되지 않았습니다", color = Palette.Safety, size = (11 * s).sp, maxLines = 2)
}
}
}
Spacer(Modifier.height((10 * s).dp))
NeoButton("결과 이미지 공유", s, Modifier.widthIn(max = 560.dp).fillMaxWidth()) {
shareCard(
ShareCard(
mode = mode.title,
headline = headline,
rows = listOf("점수" to "$score", "라인" to "$lines", "시간" to formatMs(timeMs), "PPS" to ((pps * 100).toInt() / 100.0).toString()),
nickname = Session.user?.nickname,
),
)
}
Spacer(Modifier.height((14 * s).dp))
// 앱 버튼은 광고 카드에 붙이지 않는다 (실수 클릭 방지 정책): 30분 끄기는 광고 위에 둔다.
AdFreeOffer(s, Modifier.widthIn(max = 560.dp).fillMaxWidth().padding(bottom = (14 * s).dp))
AdCard()
Spacer(Modifier.height((14 * s).dp))
Row(Modifier.widthIn(max = 560.dp).fillMaxWidth(), horizontalArrangement = Arrangement.spacedBy(12.dp)) {
@@ -405,10 +428,19 @@ fun SettingsScreen(onBack: () -> Unit, onTab: (Int) -> Unit = { if (it == 0) onB
Toggle("큰 버튼", "태블릿·폴드에서 버튼 확대", bigButtons, s) {
bigButtons = it; Prefs.setFlag("bigButtons", it)
}
if (privacyOptionsRequired()) {
NeoPanel(modifier = Modifier.fillMaxWidth(), onClick = { showPrivacyOptions() }) {
Column(Modifier.fillMaxWidth().padding((16 * s).dp)) {
Mono("광고 개인정보 설정", size = (15 * s).sp, weight = FontWeight.Bold)
Spacer(Modifier.height(4.dp))
Mono("광고 맞춤 설정 동의를 다시 선택합니다", color = Palette.Sub, size = (11 * s).sp)
}
}
}
}
}
}
TabBar(selected = 3, scale = s, onSelect = onTab)
TabBar(selected = 4, scale = s, onSelect = onTab)
}
}

View File

@@ -151,6 +151,7 @@ fun ProfileScreen(onTab: (Int) -> Unit) {
Disp(user?.nickname ?: (if (Session.offline) "오프라인" else "…"), size = (22 * s).sp)
Spacer(Modifier.width(8.dp))
if (user?.guest != false) Badge("게스트", Palette.Sub, s) else Badge("계정", Palette.Cobalt, s)
user?.badge?.let { Spacer(Modifier.width(6.dp)); UserBadge(it, s) }
}
user?.email?.let { Spacer(Modifier.height(4.dp)); Mono(it, color = Palette.Sub, size = (12 * s).sp) }
Spacer(Modifier.height(12.dp))
@@ -336,7 +337,9 @@ fun LeaderboardScreen(onTab: (Int) -> Unit) {
NeoPanel(modifier = Modifier.fillMaxWidth().padding(bottom = 6.dp), background = if (mine) Palette.Paper else Palette.Bone, shadow = false) {
Row(Modifier.padding(horizontal = 12.dp, vertical = 9.dp), verticalAlignment = Alignment.CenterVertically) {
Mono("${r.int("pos")}", Modifier.width((34 * s).dp), size = (13 * s).sp, weight = FontWeight.Bold)
Mono(r.str("nickname") ?: "?", Modifier.weight(1f), size = (13 * s).sp)
Mono(r.str("nickname") ?: "?", Modifier.weight(1f, fill = false), size = (13 * s).sp)
r.str("badge")?.let { Spacer(Modifier.width(6.dp)); UserBadge(it, s) }
Spacer(Modifier.weight(1f))
Mono(value, size = (13 * s).sp, weight = FontWeight.Bold)
}
}

View File

@@ -43,6 +43,10 @@ import kr.tkrmagid.tetrig.ads.AdBanner
import kr.tkrmagid.tetrig.ads.AdCard
import kr.tkrmagid.tetrig.ads.AdPolicy
import kr.tkrmagid.tetrig.ads.maybeInterstitial
import kr.tkrmagid.tetrig.share.ShareCard
import kr.tkrmagid.tetrig.share.shareCard
import kr.tkrmagid.tetrig.share.roomInviteText
import kr.tkrmagid.tetrig.share.shareText
import kr.tkrmagid.tetrig.data.Prefs
import kr.tkrmagid.tetrig.engine.Config
import kr.tkrmagid.tetrig.game.Conn
@@ -125,9 +129,13 @@ private fun LobbyView(client: RoomClient, onExit: () -> Unit) {
Column(Modifier.fillMaxWidth().padding((14 * s).dp), horizontalAlignment = Alignment.CenterHorizontally) {
Mono("방 코드", color = Palette.DSub, size = (12 * s).sp)
Disp(client.code ?: "------", color = Palette.Safety, size = (38 * s).sp)
Mono("친구에게 이 코드를 알려주세요", color = Palette.DSub, size = (11 * s).sp)
Mono("친구에게 코드나 초대 링크를 보내세요", color = Palette.DSub, size = (11 * s).sp)
}
}
client.code?.let { code ->
Spacer(Modifier.height((10 * s).dp))
NeoButton("초대 링크 보내기", s, Modifier.fillMaxWidth()) { shareText(roomInviteText(code)) }
}
Spacer(Modifier.height((16 * s).dp))
Mono("참가자 ${client.players.size}명", size = (13 * s).sp, weight = FontWeight.Bold)
Spacer(Modifier.height(8.dp))
@@ -174,6 +182,7 @@ private fun PlayerRow(p: RoomPlayer, isHost: Boolean, isMe: Boolean, s: Float) {
NeoPanel(modifier = Modifier.fillMaxWidth().padding(bottom = 6.dp), background = if (isMe) Palette.Paper else Palette.Bone, shadow = false) {
Row(Modifier.padding(horizontal = 12.dp, vertical = 9.dp), verticalAlignment = Alignment.CenterVertically) {
Mono(p.nick + if (isMe) " (나)" else "", Modifier.weight(1f), size = (13 * s).sp, weight = if (isMe) FontWeight.Bold else FontWeight.Normal)
p.badge?.let { UserBadge(it, s); Spacer(Modifier.width(4.dp)) }
if (p.guest) { Badge("게스트", Palette.Sub, s); Spacer(Modifier.width(4.dp)) }
if (isHost) { Badge("호스트", Palette.Safety, s); Spacer(Modifier.width(4.dp)) }
if (!p.connected) Badge("끊김", Palette.Sub, s)
@@ -426,7 +435,35 @@ private fun MatchResultView(client: RoomClient, onExit: () -> Unit, onRequeue: (
}
}
}
Spacer(Modifier.height((10 * s).dp))
NeoButton("결과 이미지 공유", s, Modifier.widthIn(max = 560.dp).fillMaxWidth()) {
val rows = if (client.kind == "league") {
val opp = m.score.keys.firstOrNull { it != client.me }
listOfNotNull(
"상대" to client.nick(opp),
"스코어" to "${m.score[client.me] ?: 0} : ${m.score[opp] ?: 0}",
m.trAfter?.let { tr -> "TR" to "$tr" + (m.trDelta?.let { d -> if (d >= 0) " (+$d)" else " ($d)" } ?: "") },
m.rankAfter?.let { "랭크" to it },
)
} else {
val mine = m.standings.firstOrNull { it.id == client.me }
listOfNotNull(
"순위" to (mine?.let { "${it.rank}위 / ${m.standings.size}명" } ?: "-"),
"라운드 승" to "${mine?.wins ?: 0}승",
)
}
shareCard(
ShareCard(
mode = if (client.kind == "league") "리그전" else "커스텀 난투",
headline = if (won) "승리!" else if (m.winner == null) "종료" else "패배",
rows = rows,
nickname = Session.user?.nickname,
),
)
}
Spacer(Modifier.height((14 * s).dp))
// 앱 버튼은 광고 카드에 붙이지 않는다 (실수 클릭 방지 정책): 30분 끄기는 광고 위에 둔다.
AdFreeOffer(s, Modifier.widthIn(max = 560.dp).fillMaxWidth().padding(bottom = (14 * s).dp))
AdCard()
Spacer(Modifier.height((14 * s).dp))
Column(Modifier.widthIn(max = 560.dp).fillMaxWidth()) {

View File

@@ -0,0 +1,358 @@
package kr.tkrmagid.tetrig.ui
import androidx.compose.foundation.Canvas
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxHeight
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.layout.widthIn
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.verticalScroll
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.produceState
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.geometry.Offset
import androidx.compose.ui.geometry.Size
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
import kr.tkrmagid.tetrig.ads.rewardedAvailable
import kr.tkrmagid.tetrig.ads.showRewarded
import kr.tkrmagid.tetrig.net.Session
import kr.tkrmagid.tetrig.net.nowMs
import kr.tkrmagid.tetrig.shop.BlockSkin
import kr.tkrmagid.tetrig.shop.BoardTheme
import kr.tkrmagid.tetrig.shop.Catalog
import kr.tkrmagid.tetrig.shop.Entitlements
import kr.tkrmagid.tetrig.shop.Loadout
import kr.tkrmagid.tetrig.shop.PassState
import kr.tkrmagid.tetrig.shop.Products
import kr.tkrmagid.tetrig.shop.SeasonPass
import kr.tkrmagid.tetrig.shop.Shop
import kr.tkrmagid.tetrig.shop.Unlock
/** 배지 한 개 (프로필·로비·리더보드 공용). */
@Composable
fun UserBadge(id: String, s: Float) {
Box(Modifier.background(Catalog.badgeColor(id)).padding(horizontal = (6 * s).dp, vertical = (2 * s).dp)) {
Mono(Catalog.badgeName(id), color = Catalog.badgeText(id), size = (10 * s).sp, weight = FontWeight.Bold)
}
}
/**
* "광고 보고 30분간 전면 광고 끄기". 시청 조건과 보상을 버튼에 먼저 적어 두고(AdMob 정책),
* 끝까지 봤을 때(onUserEarnedReward)만 적용한다. 광고 제거를 샀으면 보이지 않는다.
*/
@Composable
fun AdFreeOffer(s: Float, modifier: Modifier = Modifier) {
if (Entitlements.adsRemoved) return
val now by produceState(nowMs()) {
while (true) {
delay(15_000)
value = nowMs()
}
}
val until = Entitlements.adFreeUntil
if (until > now) {
val min = ((until - now + 59_999) / 60_000).coerceAtLeast(1)
NeoPanel(modifier = modifier, background = Palette.Paper, shadow = false) {
Mono("전면 광고 꺼짐 · ${min}분 남음", Modifier.padding(horizontal = 12.dp, vertical = (10 * s).dp), size = (12 * s).sp, weight = FontWeight.Bold)
}
return
}
val ready = rewardedAvailable()
var watching by remember { mutableStateOf(false) }
NeoPanel(modifier = modifier, shadow = false, onClick = if (ready && !watching) ({
watching = true
showRewarded { earned ->
watching = false
if (earned) Entitlements.grantAdFree()
}
}) else null) {
Column(Modifier.padding(horizontal = 12.dp, vertical = (10 * s).dp)) {
Mono(
if (watching) "광고 재생 중…" else if (ready) "▶ 광고 1편 보고 30분간 전면 광고 끄기" else "30분 전면 광고 끄기 · 광고 준비 중",
size = (12 * s).sp, weight = FontWeight.Bold, color = if (ready) Palette.Ink else Palette.Sub,
)
Mono("끝까지 보면 30분 동안 판 사이 전면 광고가 나오지 않습니다", color = Palette.Sub, size = (10 * s).sp, maxLines = 2)
}
}
}
@Composable
fun ShopScreen(onTab: (Int) -> Unit) {
val s = LocalLayout.current.uiScale
LaunchedEffect(Unit) {
Session.refresh()
SeasonPass.load()
}
Column(Modifier.fillMaxSize()) {
Column(Modifier.weight(1f).verticalScroll(rememberScrollState()).padding((20 * s).dp)) {
TopBar("상점", s, null)
Shop.message?.let {
Spacer(Modifier.height(8.dp))
Mono(it, color = Palette.Safety, size = (12 * s).sp, weight = FontWeight.Bold, maxLines = 3)
}
Spacer(Modifier.height((14 * s).dp))
Box(Modifier.widthIn(max = 720.dp)) {
Column {
PassSection(s)
Spacer(Modifier.height((22 * s).dp))
Section("블록 스킨", s)
Catalog.skins.chunked(2).forEach { row ->
Row(horizontalArrangement = Arrangement.spacedBy(10.dp), modifier = Modifier.padding(bottom = 10.dp)) {
row.forEach { SkinCard(it, s, Modifier.weight(1f)) }
if (row.size == 1) Spacer(Modifier.weight(1f))
}
}
Spacer(Modifier.height((12 * s).dp))
Section("보드 테마", s)
Catalog.boards.chunked(2).forEach { row ->
Row(horizontalArrangement = Arrangement.spacedBy(10.dp), modifier = Modifier.padding(bottom = 10.dp)) {
row.forEach { BoardCard(it, s, Modifier.weight(1f)) }
if (row.size == 1) Spacer(Modifier.weight(1f))
}
}
Spacer(Modifier.height((12 * s).dp))
BadgeSection(s)
Spacer(Modifier.height((22 * s).dp))
ProductSection(s)
Spacer(Modifier.height((16 * s).dp))
AdFreeOffer(s, Modifier.fillMaxWidth())
}
}
}
TabBar(selected = 3, scale = s, onSelect = onTab)
}
}
@Composable
private fun Section(title: String, s: Float, sub: String? = null) {
Disp(title, size = (18 * s).sp)
if (sub != null) Mono(sub, color = Palette.Sub, size = (11 * s).sp, maxLines = 3)
Spacer(Modifier.height(8.dp))
}
private fun unlockLabel(u: Unlock): String = when (u) {
Unlock.Free -> "기본"
Unlock.Rewarded -> "광고 보고 해금"
Unlock.Supporter -> "서포터 팩 전용"
is Unlock.Pass -> "시즌 패스 Lv ${u.level}" + if (u.premium) " · 프리미엄" else ""
}
/** 아이템 카드 아래 버튼: 장착 / 장착 중 / 해금 방법. */
@Composable
private fun ItemAction(item: String, unlock: Unlock, equipped: Boolean, s: Float, onEquip: () -> Unit) {
val owned = Loadout.owns(item)
when {
equipped -> Mono("장착 중", Modifier.fillMaxWidth().padding(vertical = 6.dp), color = Palette.Safety, size = (12 * s).sp, weight = FontWeight.Bold)
owned -> NeoButton("장착", s, Modifier.fillMaxWidth(), onClick = onEquip)
unlock == Unlock.Rewarded -> {
val ready = rewardedAvailable()
NeoButton(if (ready) "▶ 광고 보고 해금" else "광고 준비 중", s, Modifier.fillMaxWidth(), enabled = ready) {
showRewarded { earned -> if (earned) { Entitlements.grantLocalItem(item); onEquip() } }
}
}
else -> Mono(unlockLabel(unlock), Modifier.fillMaxWidth().padding(vertical = 6.dp), color = Palette.Sub, size = (11 * s).sp, maxLines = 2)
}
}
@Composable
private fun SkinCard(skin: BlockSkin, s: Float, modifier: Modifier) {
val equipped = Loadout.skin.id == skin.id
NeoPanel(modifier = modifier, shadow = equipped) {
Column(Modifier.padding((10 * s).dp)) {
val bg = Loadout.board.bg
Row(
Modifier.fillMaxWidth().height((44 * s).dp).background(bg).padding(4.dp),
horizontalArrangement = Arrangement.spacedBy(2.dp),
) {
for (t in listOf('T', 'I', 'S', 'L')) {
Box(Modifier.weight(1f).fillMaxHeight()) { MiniPieceCanvas(t, skin, bg) }
}
}
Spacer(Modifier.height(6.dp))
Mono(skin.name, size = (13 * s).sp, weight = FontWeight.Bold)
ItemAction(skin.item, skin.unlock, equipped, s) { Loadout.equipSkin(skin.id) }
}
}
}
@Composable
private fun BoardCard(theme: BoardTheme, s: Float, modifier: Modifier) {
val equipped = Loadout.board.id == theme.id
NeoPanel(modifier = modifier, shadow = equipped) {
Column(Modifier.padding((10 * s).dp)) {
val skin = Loadout.skin
Canvas(Modifier.fillMaxWidth().height((44 * s).dp)) {
drawRect(theme.bg)
val c = size.height / 4
theme.grid?.let { g ->
var x = 0f
while (x <= size.width) { drawLine(g, Offset(x, 0f), Offset(x, size.height), 1f); x += c }
for (i in 0..4) drawLine(g, Offset(0f, i * c), Offset(size.width, i * c), 1f)
}
val cells = listOf(0 to 3, 1 to 3, 2 to 3, 1 to 2, 5 to 3, 6 to 3, 6 to 2, 6 to 1)
cells.forEachIndexed { i, (x, y) ->
skinBlock(skin, if (i < 4) 'T' else 'L', Offset(x * c + 1f, y * c + 1f), Size(c - 2f, c - 2f), theme.bg)
}
}
Spacer(Modifier.height(6.dp))
Mono(theme.name, size = (13 * s).sp, weight = FontWeight.Bold)
ItemAction(theme.item, theme.unlock, equipped, s) { Loadout.equipBoard(theme.id) }
}
}
}
@Composable
private fun BadgeSection(s: Float) {
val scope = rememberCoroutineScope()
var msg by remember { mutableStateOf<String?>(null) }
val owned = Loadout.serverItems.keys.filter { it.startsWith("badge:") }.map { it.removePrefix("badge:") }.sorted()
val current = Session.user?.badge
Section("배지", s, "닉네임 옆에 붙어 로비·리더보드에서 다른 플레이어에게 보입니다. 시즌 패스·서포터 팩으로 얻습니다.")
if (owned.isEmpty()) {
Mono("아직 가진 배지가 없습니다", color = Palette.Sub, size = (12 * s).sp)
}
for (id in owned) {
NeoPanel(modifier = Modifier.fillMaxWidth().padding(bottom = 6.dp), shadow = false) {
Row(Modifier.padding(horizontal = 12.dp, vertical = 8.dp), verticalAlignment = Alignment.CenterVertically) {
UserBadge(id, s)
Spacer(Modifier.weight(1f))
val on = current == id
NeoPanel(shadow = false, background = if (on) Palette.Safety else Palette.Bone, onClick = {
scope.launch { msg = Session.equipBadge(if (on) null else id) }
}) {
Mono(if (on) "장착 중 · 해제" else "장착", Modifier.padding(horizontal = 10.dp, vertical = 5.dp), size = (12 * s).sp, weight = FontWeight.Bold)
}
}
}
}
msg?.let { Mono(it, color = Palette.Safety, size = (12 * s).sp, maxLines = 2) }
}
@Composable
private fun PassSection(s: Float) {
val p = SeasonPass.state
Section("시즌 패스", s, "게임을 할수록 XP 가 쌓여 레벨 보상을 받습니다. 솔로 1판 +10 · 커스텀 +20(1위 +10) · 리그 +25(승리 +15)")
if (p == null) {
Mono(SeasonPass.error ?: "불러오는 중…", color = Palette.Sub, size = (12 * s).sp, maxLines = 2)
return
}
NeoPanel(modifier = Modifier.fillMaxWidth()) {
Column(Modifier.padding((14 * s).dp)) {
Row(verticalAlignment = Alignment.CenterVertically) {
val days = if (p.endsAt > 0) ((p.endsAt - nowMs()) / 86_400_000L).coerceAtLeast(0) else null
Disp("SEASON ${p.season}", size = (18 * s).sp)
Spacer(Modifier.width(8.dp))
days?.let { Mono("D-$it", color = Palette.Sub, size = (12 * s).sp) }
Spacer(Modifier.weight(1f))
if (p.premium) Badge("프리미엄", Palette.Safety, s)
}
Spacer(Modifier.height(8.dp))
Mono("Lv ${p.level} / ${p.maxLevel}" + if (p.level < p.maxLevel) " · ${p.xpInLevel}/${p.xpPerLevel} XP" else " · 완주", size = (14 * s).sp, weight = FontWeight.Bold)
Spacer(Modifier.height(6.dp))
val frac = (p.xpInLevel.toFloat() / p.xpPerLevel).coerceIn(0f, 1f)
Box(Modifier.fillMaxWidth().height((10 * s).dp).background(Palette.Paper)) {
Box(Modifier.fillMaxWidth(frac).fillMaxHeight().background(Palette.Cobalt))
}
Spacer(Modifier.height(10.dp))
PassBuy(p, s)
}
}
Spacer(Modifier.height(10.dp))
for (t in p.tiers) {
// 실제로 받은 보상이 있는 칸만 "획득" (프리미엄 전용 칸은 패스가 있어야 받는다)
val reached = p.level >= t.level && (t.free != null || p.premium)
NeoPanel(modifier = Modifier.fillMaxWidth().padding(bottom = 6.dp), background = if (reached) Palette.Paper else Palette.Bone, shadow = false) {
Row(Modifier.padding(horizontal = 10.dp, vertical = 8.dp), verticalAlignment = Alignment.CenterVertically) {
Mono("Lv ${t.level}", Modifier.width((50 * s).dp), size = (12 * s).sp, weight = FontWeight.Bold)
Column(Modifier.weight(1f)) {
t.free?.let { Mono("무료 · " + Catalog.itemName(it), size = (11 * s).sp, maxLines = 2) }
t.premium?.let {
Mono(
"프리미엄 · " + Catalog.itemName(it), size = (11 * s).sp, maxLines = 2,
color = if (p.premium) Palette.Ink else Palette.Sub,
)
}
}
Mono(if (reached) "획득" else "", color = Palette.Safety, size = (11 * s).sp, weight = FontWeight.Bold)
}
}
}
Mono("받은 보상은 시즌이 끝나도 계속 쓸 수 있습니다. 프리미엄은 이번 시즌에만 적용되고, 이미 지난 레벨의 보상도 바로 받습니다.", color = Palette.Sub, size = (11 * s).sp, maxLines = 3)
}
@Composable
private fun PassBuy(p: PassState, s: Float) {
when {
p.premium -> Mono("프리미엄 트랙 보상을 받고 있습니다", color = Palette.Sub, size = (12 * s).sp)
Shop.passPending -> Mono("결제 확인 중… 잠시 뒤 다시 열어 주세요", color = Palette.Sub, size = (12 * s).sp, maxLines = 2)
!p.purchasable -> Mono("프리미엄 패스는 준비 중입니다", color = Palette.Sub, size = (12 * s).sp)
else -> NeoButton(
"프리미엄 패스 구매 · " + (Shop.prices[Products.SEASON_PASS] ?: Products.listPrice(Products.SEASON_PASS)), s,
Modifier.fillMaxWidth(), accent = true, enabled = Shop.prices[Products.SEASON_PASS] != null,
) { Shop.buy(Products.SEASON_PASS) }
}
}
@Composable
private fun ProductSection(s: Float) {
Section("상품", s, "한 번 사면 계속 유지되고, 같은 Google 계정이면 다른 기기에서도 '구매 복원'으로 되살릴 수 있습니다.")
ProductCard(
Products.REMOVE_ADS, "광고 제거",
"배너·결과 화면 광고·전면 광고가 모두 사라집니다. 원하면 보상형 광고는 계속 볼 수 있습니다.",
owned = Entitlements.owns(Products.REMOVE_ADS) || Entitlements.owns(Products.SUPPORTER), s = s,
)
ProductCard(
Products.SUPPORTER, "서포터 팩",
"광고 제거 + 서포터 전용 블록 스킨 + SUPPORTER 배지. 개발을 응원해 주세요.",
owned = Entitlements.owns(Products.SUPPORTER), s = s,
)
NeoButton("구매 복원", s, Modifier.fillMaxWidth()) { Shop.restore() }
if (!Shop.connected) {
Spacer(Modifier.height(6.dp))
Mono("Play 스토어에 연결되지 않아 지금은 구매할 수 없습니다", color = Palette.Sub, size = (11 * s).sp, maxLines = 2)
}
}
@Composable
private fun ProductCard(id: String, title: String, desc: String, owned: Boolean, s: Float) {
NeoPanel(modifier = Modifier.fillMaxWidth().padding(bottom = 10.dp)) {
Column(Modifier.padding((14 * s).dp)) {
Row(verticalAlignment = Alignment.CenterVertically) {
Disp(title, size = (17 * s).sp)
Spacer(Modifier.weight(1f))
if (owned) Badge("보유 중", Palette.Cobalt, s)
}
Spacer(Modifier.height(4.dp))
Mono(desc, color = Palette.Sub, size = (11 * s).sp, maxLines = 3)
if (!owned) {
Spacer(Modifier.height(10.dp))
val price = Shop.prices[id]
NeoButton(
"구매 · " + (price ?: Products.listPrice(id)), s, Modifier.fillMaxWidth(),
accent = true, enabled = price != null,
) { Shop.buy(id) }
}
}
}
}

View File

@@ -0,0 +1,54 @@
package kr.tkrmagid.tetrig.ui
import androidx.compose.ui.geometry.Offset
import androidx.compose.ui.geometry.Size
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.Path
import androidx.compose.ui.graphics.drawscope.DrawScope
import androidx.compose.ui.graphics.drawscope.Stroke
import kr.tkrmagid.tetrig.shop.BlockSkin
import kr.tkrmagid.tetrig.shop.BlockStyle
/**
* 스킨 규칙대로 블록 한 칸을 그린다. 모두 플랫 도형만 쓴다 (그라디언트·블러 없음).
* - Solid: 꽉 찬 사각형 (기본)
* - Inset: 채움 + 안쪽 잉크 테두리
* - Outline: 색 테두리만
* - Chamfer: 우하단 모서리를 잘라 낸 블록 (네오브루탈 시그니처 컷)
* - Plate: 채움 + 잉크 테두리 + 본(BONE) 챔퍼 (서포터 전용)
*/
fun DrawScope.skinBlock(skin: BlockSkin, type: Char, topLeft: Offset, cell: Size, bg: Color) {
val color = skin.color(type)
val w = cell.width
val h = cell.height
val k = minOf(w, h)
when (skin.style) {
BlockStyle.Solid -> drawRect(color, topLeft, cell)
BlockStyle.Inset -> {
drawRect(color, topLeft, cell)
val t = (k * 0.14f).coerceAtLeast(1f)
drawRect(Palette.Ink, Offset(topLeft.x + t / 2, topLeft.y + t / 2), Size(w - t, h - t), style = Stroke(t))
}
BlockStyle.Outline -> {
val t = (k * 0.18f).coerceAtLeast(1.5f)
drawRect(color, Offset(topLeft.x + t / 2, topLeft.y + t / 2), Size(w - t, h - t), style = Stroke(t))
}
BlockStyle.Chamfer -> {
drawRect(color, topLeft, cell)
drawPath(corner(topLeft, w, h, k * 0.38f), bg)
}
BlockStyle.Plate -> {
drawRect(color, topLeft, cell)
val t = (k * 0.12f).coerceAtLeast(1f)
drawRect(Palette.Ink, Offset(topLeft.x + t / 2, topLeft.y + t / 2), Size(w - t, h - t), style = Stroke(t))
drawPath(corner(topLeft, w, h, k * 0.34f), Palette.Bone)
}
}
}
private fun corner(tl: Offset, w: Float, h: Float, c: Float) = Path().apply {
moveTo(tl.x + w, tl.y + h - c)
lineTo(tl.x + w, tl.y + h)
lineTo(tl.x + w - c, tl.y + h)
close()
}

View File

@@ -0,0 +1,136 @@
package kr.tkrmagid.tetrig.game
import kr.tkrmagid.tetrig.ads.interstitialDue
import kr.tkrmagid.tetrig.share.DeepLink
import kr.tkrmagid.tetrig.shop.Catalog
import kr.tkrmagid.tetrig.shop.Unlock
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertFalse
import kotlin.test.assertNull
import kotlin.test.assertTrue
class MonetizationTest {
/** 세션마다 perSession 판씩 할 때 전면 광고가 뜨는 누적 판 번호 (앱을 껐다 켜도 이어 센다). */
private fun adGames(perSession: Int, sessions: Int): List<Int> {
var total = 0
var last = 0
val shown = mutableListOf<Int>()
repeat(sessions) {
var session = 0
repeat(perSession) {
total++
session++
if (interstitialDue(total, last, session)) {
shown += total
last = total
}
}
}
return shown
}
@Test
fun twoPerSessionGetsAdEveryFourthGame() {
assertEquals(listOf(4, 8, 12), adGames(perSession = 2, sessions = 6))
}
@Test
fun threePerSessionKeepsEveryThirdGame() {
assertEquals(listOf(3, 6, 9, 12), adGames(perSession = 3, sessions = 4))
}
@Test
fun oneGameSessionsNeverShow() {
assertEquals(emptyList(), adGames(perSession = 1, sessions = 10))
}
@Test
fun longSessionEveryThird() {
assertEquals(listOf(3, 6, 9), adGames(perSession = 10, sessions = 1))
}
@Test
fun sameGameNotShownTwice() {
// 결과 화면에서 버튼을 두 번 눌러도(markShown 후) 다시 뜨지 않는다.
assertTrue(interstitialDue(total = 3, lastShownAt = 0, session = 3))
assertFalse(interstitialDue(total = 3, lastShownAt = 3, session = 3))
}
private fun topOut(state: GameState) {
var n = 0
while (!state.finished && !state.awaitingContinue && n++ < 500) state.hardDrop()
}
@Test
fun timeAttackContinueOnceAndMarksRun() {
val s = GameState(Mode.TimeAttack, 7)
s.canOfferContinue = { true }
topOut(s)
assertTrue(s.awaitingContinue)
assertFalse(s.finished)
val scoreBefore = s.score
val elapsedBefore = s.elapsedMs
s.tick(5_000) // 선택을 기다리는 동안 시간은 멈춘다
assertEquals(elapsedBefore, s.elapsedMs)
s.acceptContinue()
assertTrue(s.continued)
assertFalse(s.awaitingContinue)
assertFalse(s.game.over)
assertEquals(scoreBefore, s.score)
// 두 번째 톱아웃은 묻지 않고 끝난다 (1판 1회).
topOut(s)
assertTrue(s.finished)
assertFalse(s.awaitingContinue)
}
@Test
fun timeAttackWithoutAdFinishesImmediately() {
val s = GameState(Mode.TimeAttack, 7)
s.canOfferContinue = { false }
topOut(s)
assertTrue(s.finished)
assertFalse(s.continued)
}
@Test
fun declineContinueFinishes() {
val s = GameState(Mode.TimeAttack, 3)
s.canOfferContinue = { true }
topOut(s)
s.declineContinue()
assertTrue(s.finished)
assertFalse(s.continued)
}
@Test
fun sprintNeverOffersContinue() {
val s = GameState(Mode.Sprint, 5)
s.canOfferContinue = { true }
topOut(s)
assertTrue(s.finished)
assertFalse(s.awaitingContinue)
}
@Test
fun inviteLinkParsing() {
assertEquals("ABC234", DeepLink.roomFromPath("/r/ABC234"))
assertEquals("ABC234", DeepLink.roomFromPath("/r/abc234/"))
assertNull(DeepLink.roomFromPath("/r/ABC"))
assertNull(DeepLink.roomFromPath("/privacy"))
assertNull(DeepLink.roomFromPath(null))
}
@Test
fun catalogIdsUniqueAndDefaultsFree() {
assertEquals(Catalog.skins.size, Catalog.skins.map { it.id }.toSet().size)
assertEquals(Catalog.boards.size, Catalog.boards.map { it.id }.toSet().size)
assertEquals(Unlock.Free, Catalog.defaultSkin.unlock)
assertEquals(Unlock.Free, Catalog.defaultBoard.unlock)
assertEquals("S3 엘리트", Catalog.badgeName("s3_elite"))
assertEquals("SUPPORTER", Catalog.badgeName("supporter"))
}
}

View File

@@ -10,15 +10,17 @@ kotlin.code.style=official
kotlin.daemon.jvmargs=-Xmx2g
# 버전은 CI/로컬에서 -PappVersionName -PappVersionCode 로 덮어쓸 수 있다.
appVersionName=2.1.0
appVersionCode=7
appVersionName=2.2.1
appVersionCode=9
# AdMob — 비워 두면 Google 공식 테스트 광고 ID 를 쓴다. 실제 ID 를 받으면 여기만 채운다.
# admobAppId=ca-app-pub-XXXXXXXXXXXXXXXX~YYYYYYYYYY
# admobBanner=ca-app-pub-XXXXXXXXXXXXXXXX/ZZZZZZZZZZ (메인·로비 하단 적응형 배너)
# admobCard=ca-app-pub-XXXXXXXXXXXXXXXX/ZZZZZZZZZZ (결과 화면 300×250)
# admobInterstitial=ca-app-pub-XXXXXXXXXXXXXXXX/ZZZZZZZZZZ (전면, 3판당 1회)
admobAppId=
admobBanner=
admobCard=
admobInterstitial=
# admobInterstitial=ca-app-pub-XXXXXXXXXXXXXXXX/ZZZZZZZZZZ (전면, 마지막 전면 뒤 3판 이상)
# admobRewarded=ca-app-pub-XXXXXXXXXXXXXXXX/ZZZZZZZZZZ (보상형: 30분 끄기·이어하기·스킨 해금)
admobAppId=ca-app-pub-5620940055268952~3764791006
admobBanner=ca-app-pub-5620940055268952/3629059638
admobCard=ca-app-pub-5620940055268952/9185647802
admobInterstitial=ca-app-pub-5620940055268952/8689814623
admobRewarded=ca-app-pub-5620940055268952/4818852372

View File

@@ -8,6 +8,9 @@ kotlinx-serialization = "1.9.0"
okhttp = "4.12.0"
play-services-ads = "25.5.0"
ump = "4.0.0"
billing = "9.1.0"
admob-applovin = "13.6.4.2"
admob-pangle = "8.4.0.5.0"
[libraries]
androidx-activity-compose = { module = "androidx.activity:activity-compose", version.ref = "androidx-activityCompose" }
@@ -16,6 +19,9 @@ kotlinx-serialization-json = { module = "org.jetbrains.kotlinx:kotlinx-serializa
okhttp = { module = "com.squareup.okhttp3:okhttp", version.ref = "okhttp" }
play-services-ads = { module = "com.google.android.gms:play-services-ads", version.ref = "play-services-ads" }
ump = { module = "com.google.android.ump:user-messaging-platform", version.ref = "ump" }
billing = { module = "com.android.billingclient:billing", version.ref = "billing" }
admob-applovin = { module = "com.google.ads.mediation:applovin", version.ref = "admob-applovin" }
admob-pangle = { module = "com.google.ads.mediation:pangle", version.ref = "admob-pangle" }
kotlin-test = { module = "org.jetbrains.kotlin:kotlin-test", version.ref = "kotlin" }
[plugins]

View File

@@ -24,6 +24,10 @@ dependencyResolutionManagement {
}
}
mavenCentral()
// Pangle SDK (AdMob 미디에이션 어댑터가 의존)
maven("https://artifact.bytedance.com/repository/pangle") {
mavenContent { includeGroupAndSubgroups("com.pangle") }
}
}
}

14
scripts/build-pages.sh Executable file
View File

@@ -0,0 +1,14 @@
#!/usr/bin/env bash
# Cloudflare Pages 배포본(dist/) 조립: PWA + 개인정보처리방침 + 초대 링크 안내 페이지 + 앱 링크 검증 파일.
# scripts/build-pages.sh && npx wrangler pages deploy dist --project-name tetrig --branch main
set -euo pipefail
ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
cd "$ROOT"
node build.js
rm -rf dist && mkdir -p dist/r dist/.well-known
cp index.html sw.js manifest.webmanifest icon-192.png icon-512.png apple-touch-icon.png dist/
cp store/privacy.html dist/privacy.html
cp store/room.html dist/r/index.html
cp store/_redirects dist/_redirects
cp .well-known/assetlinks.json dist/.well-known/assetlinks.json
echo "dist/ 준비 완료"

View File

@@ -7,6 +7,7 @@
- `src/room.js` — GameRoomDO (WebSocket Hibernation, 상태는 DO storage 에 저장)
- `src/matchmaker.js` / `src/matchmaking.js` — 리그 대기열 (R ± 2×RD, 30초마다 ×1.2 확장)
- `src/glicko.js` — Glicko-2, `src/rules.js` — 튜닝 상수 전부
- `src/shop.js` — 시즌 패스(XP·레벨·보상 트랙)·꾸미기 아이템·배지·Play 구매 적용, `src/play.js` — Google Play 영수증 확인
- `migrations/` — D1 스키마
## 개발
@@ -18,6 +19,10 @@ printf 'TOKEN_SECRET=dev\n' > .dev.vars
npx wrangler d1 migrations apply tetrig --local
npx wrangler dev --local --port 8799
node scripts/e2e.mjs http://127.0.0.1:8799 # 종단 테스트 (게스트·FFA·계정·리그)
# 시즌 패스·결제·배지 (가짜 영수증은 로컬 + PLAY_VERIFY_FAKE=1 일 때만 통과)
npx wrangler dev --local --port 8799 --var PLAY_VERIFY_FAKE:1
node scripts/e2e-shop.mjs http://127.0.0.1:8799
```
## 배포
@@ -31,6 +36,10 @@ npx wrangler deploy
비밀값 `TOKEN_SECRET` 은 `wrangler secret put` 으로만 넣는다 (재설정하면 기존 로그인 세션이 모두 끊김).
Google 로그인은 `wrangler.toml` 의 `GOOGLE_CLIENT_IDS` 에 OAuth 클라이언트 ID 를 넣으면 켜진다.
Play 결제 확인은 `PLAY_SA_KEY`(서비스 계정 JSON 키 전체)를 `wrangler secret put PLAY_SA_KEY` 로 넣으면 켜진다.
서비스 계정은 Google Cloud 에서 만들고, Play Console > 사용자 및 권한에 초대해 "재무 데이터 보기 / 주문 관리" 권한을 준다.
없으면 `/api/purchase` 는 503, `/api/pass` 의 `purchasable` 은 false (앱이 시즌 패스 구매 버튼을 숨김).
## API 요약
| 경로 | 설명 |
@@ -41,7 +50,10 @@ Google 로그인은 `wrangler.toml` 의 `GOOGLE_CLIENT_IDS` 에 OAuth 클라이
| `POST /api/google` | Google ID 토큰 로그인 |
| `GET /api/me` | 프로필·리그 요약·솔로 베스트·최근 전적 |
| `POST /api/nickname` · `GET /api/nickname/check?n=` | 닉 변경(30일 쿨다운) · 중복 검사 |
| `POST /api/solo` | 솔로 베스트 제출 `{mode, value}` |
| `POST /api/solo` | 솔로 베스트 제출 `{mode, value}` (+시즌 패스 XP). `{mode, xpOnly:true}` 는 기록 없이 XP 만 |
| `GET /api/pass` | 시즌 패스: 시즌·XP·레벨·프리미엄 여부·보상 트랙 |
| `POST /api/purchase` | Play 구매 적용 `{productId, purchaseToken}` → `{ok, consume, items}` |
| `POST /api/badge` | 배지 장착 `{badge}` (null 이면 해제, 가진 배지만) |
| `GET /api/leaderboard?board=league\|sprint\|time\|endless` | 상위 100 (계정만) |
| `POST /api/rooms` · `GET /api/rooms/:code` | 커스텀 방 생성 · 조회 |
| `WS /ws/room/:code` · `WS /ws/league/:id` · `WS /ws/queue` | 경기방 · 리그 경기 · 리그 대기열 (`?token=`) |

View File

@@ -0,0 +1,29 @@
-- 수익화: 시즌 패스 XP · 꾸미기 아이템 · Play 결제 기록 · 장착 배지
CREATE TABLE IF NOT EXISTS season_xp (
user_id TEXT NOT NULL,
season INTEGER NOT NULL,
xp INTEGER NOT NULL DEFAULT 0,
premium INTEGER NOT NULL DEFAULT 0, -- 이번 시즌 프리미엄 패스 보유
last_solo_at INTEGER, -- 솔로 XP 남용 방지 (최소 간격)
PRIMARY KEY (user_id, season)
);
CREATE TABLE IF NOT EXISTS user_items (
user_id TEXT NOT NULL,
item TEXT NOT NULL, -- 'skin:chalk' | 'board:oxide' | 'badge:s1_elite' ...
source TEXT, -- 'pass:s1' | 'purchase:<token 앞부분>'
created_at INTEGER,
PRIMARY KEY (user_id, item)
);
CREATE TABLE IF NOT EXISTS purchases (
token TEXT PRIMARY KEY, -- Play purchaseToken (한 구매는 한 계정에만 묶인다)
user_id TEXT NOT NULL,
product TEXT NOT NULL,
order_id TEXT,
season INTEGER, -- season_pass 를 적용한 시즌
created_at INTEGER
);
CREATE INDEX IF NOT EXISTS purchases_user ON purchases(user_id);
ALTER TABLE users ADD COLUMN badge TEXT;

View File

@@ -0,0 +1,92 @@
// 시즌 패스·결제·배지 종단 테스트 (로컬 전용: 가짜 영수증을 쓴다).
// npx wrangler dev --local --port 8799 --var PLAY_VERIFY_FAKE:1
// node scripts/e2e-shop.mjs http://127.0.0.1:8799
const BASE = process.argv[2] || "http://127.0.0.1:8799";
const WS = BASE.replace(/^http/, "ws");
let fails = 0;
const check = (cond, label) => { console.log(`${cond ? "✓" : "✗"} ${label}`); if (!cond) fails++; };
const rnd = () => Math.random().toString(36).slice(2, 10);
async function api(path, { method = "GET", token, body } = {}) {
const res = await fetch(BASE + path, {
method, headers: { "Content-Type": "application/json", ...(token ? { Authorization: `Bearer ${token}` } : {}) },
body: body ? JSON.stringify(body) : undefined,
});
return { status: res.status, data: await res.json().catch(() => null) };
}
const guest = async () => (await api("/api/guest", { method: "POST", body: { deviceId: "shop-" + rnd() } })).data;
const A = await guest();
const B = await guest();
let p = (await api("/api/pass", { token: A.token })).data;
check(p.level === 1 && p.xp === 0 && p.premium === false && p.purchasable === true && p.tiers.length === 9, "패스 초기 상태 Lv1, 0XP, 구매 가능(로컬 가짜 검증)");
let r = await api("/api/solo", { method: "POST", token: A.token, body: { mode: "sprint", value: 61_000 } });
check(r.status === 200 && r.data.xp.xp === 10, "솔로 1판 +10 XP");
r = await api("/api/solo", { method: "POST", token: A.token, body: { mode: "time", xpOnly: true } });
check(r.data.xp.throttled === true && r.data.xp.xp === 10, "20초 안에 또 보내면 XP 없음");
check((await api("/api/me", { token: A.token })).data.solo.time === undefined, "xpOnly 판은 기록에 안 남음");
// ── 서포터 팩 ──
const sup = "fake-0-sup" + rnd() + rnd();
r = await api("/api/purchase", { method: "POST", token: A.token, body: { productId: "supporter_pack", purchaseToken: sup } });
check(r.status === 200 && r.data.consume === false && r.data.items.includes("badge:supporter") && r.data.items.includes("skin:supporter"), "서포터 팩: 배지·스킨 지급, 소비 안 함");
r = await api("/api/purchase", { method: "POST", token: A.token, body: { productId: "supporter_pack", purchaseToken: sup } });
check(r.status === 200, "같은 구매 재전송은 그대로 성공 (멱등)");
r = await api("/api/badge", { method: "POST", token: A.token, body: { badge: "supporter" } });
check(r.status === 200 && r.data.user.badge === "supporter", "SUPPORTER 배지 장착");
r = await api("/api/badge", { method: "POST", token: A.token, body: { badge: "s1_elite" } });
check(r.status === 403, "없는 배지는 장착 불가");
let me = (await api("/api/me", { token: A.token })).data;
check(me.user.badge === "supporter" && me.items.includes("skin:supporter") && me.pass.level === 1, "/api/me 에 배지·아이템·패스 요약");
// 계정 승격 → 리더보드에 배지
const email = `shop${rnd()}@example.com`;
r = await api("/api/register", { method: "POST", token: A.token, body: { email, password: "password123" } });
check(r.status === 200 && r.data.user.badge === "supporter", "게스트 → 계정 승격 후에도 배지 유지");
const lb = (await api("/api/leaderboard?board=sprint")).data.rows.find((x) => x.id === A.user.id);
check(lb?.badge === "supporter", "리더보드 행에 배지");
// 같은 Google 구매를 다른 게임 계정에서 복원 → 옮겨진다
r = await api("/api/purchase", { method: "POST", token: B.token, body: { productId: "supporter_pack", purchaseToken: sup } });
check(r.status === 200 && r.data.items.includes("badge:supporter"), "다른 계정에서 복원하면 그 계정으로 이전");
me = (await api("/api/me", { token: A.token })).data;
check(me.user.badge === null && !me.items.includes("badge:supporter"), "원래 계정은 배지·아이템 회수");
// ── 시즌 패스 ──
const pass1 = "fake-0-pass" + rnd() + rnd();
r = await api("/api/purchase", { method: "POST", token: B.token, body: { productId: "season_pass", purchaseToken: pass1 } });
check(r.status === 200 && r.data.consume === true && r.data.items.includes("board:oxide"), "시즌 패스: 프리미엄 + Lv1 보상 소급, 소비 허용");
p = (await api("/api/pass", { token: B.token })).data;
check(p.premium === true, "패스 프리미엄 활성");
r = await api("/api/purchase", { method: "POST", token: B.token, body: { productId: "season_pass", purchaseToken: "fake-0-pass" + rnd() + rnd() } });
check(r.status === 409, "같은 시즌에 두 번째 패스는 적용 안 함 (409, 소비하지 않음)");
r = await api("/api/purchase", { method: "POST", token: A.token, body: { productId: "season_pass", purchaseToken: pass1 } });
check(r.status === 409, "다른 계정에 쓴 패스 영수증은 거절");
r = await api("/api/purchase", { method: "POST", token: A.token, body: { productId: "remove_ads", purchaseToken: "fake-2-pend" + rnd() + rnd() } });
check(r.status === 425, "결제 대기 중 구매는 425 (나중에 재시도)");
r = await api("/api/purchase", { method: "POST", token: A.token, body: { productId: "remove_ads", purchaseToken: "fake-1-canc" + rnd() + rnd() } });
check(r.status === 410, "취소된 구매는 410");
r = await api("/api/purchase", { method: "POST", token: A.token, body: { productId: "gems_9999", purchaseToken: "fake-0-x" + rnd() + rnd() } });
check(r.status === 400, "모르는 상품은 400");
// ── 로비에 배지 ──
await api("/api/badge", { method: "POST", token: B.token, body: { badge: "supporter" } });
const { data: room } = await api("/api/rooms", { method: "POST", token: B.token, body: { rules: {} } });
const ws = new WebSocket(`${WS}/ws/room/${room.code}?token=${B.token}`);
const lobby = await new Promise((res, rej) => {
const to = setTimeout(() => rej(new Error("lobby timeout")), 8000);
ws.onmessage = (e) => { const m = JSON.parse(e.data); if (m.t === "lobby") { clearTimeout(to); res(m); } };
});
check(lobby.players.find((x) => x.id === B.user.id)?.badge === "supporter", "커스텀 로비 플레이어 목록에 배지");
ws.close();
// ── 계정(게스트) 삭제 → 구매 기록도 지워져 다시 복원 가능 ──
r = await api("/api/me/delete", { method: "POST", token: B.token });
check(r.status === 200, "B 삭제");
r = await api("/api/purchase", { method: "POST", token: A.token, body: { productId: "supporter_pack", purchaseToken: sup } });
check(r.status === 200 && r.data.items.includes("badge:supporter"), "삭제된 계정의 비소모성 구매를 새 계정에서 복원");
console.log(fails ? `\n${fails}개 실패` : "\n전부 통과");
process.exit(fails ? 1 : 0);

View File

@@ -1,5 +1,6 @@
// D1 접근 헬퍼. Worker 와 DO 가 공유한다.
import { glickoUpdate } from "./glicko.js";
import { PASS, awardXp, mergeShopStatements } from "./shop.js";
import {
GLICKO, PLACEMENT_GAMES, RANK_VISIBLE_RD, RD_DECAY_IDLE_DAYS, RD_DECAY_PER_DAY, SEASON_LENGTH_DAYS,
rankFor, trFor,
@@ -23,7 +24,7 @@ export function publicUser(u) {
if (!u) return null;
return {
id: u.id, nickname: u.nickname, guest: !!u.is_guest, email: u.email ?? null,
google: !!u.google_sub, nicknameChangedAt: u.nickname_changed_at ?? null,
google: !!u.google_sub, nicknameChangedAt: u.nickname_changed_at ?? null, badge: u.badge ?? null,
};
}
@@ -88,6 +89,11 @@ export async function applyLeagueResult(db, { matchId, winner, loser, score }, n
)
.bind(matchId, season, now, winner, loser, score[winner] ?? 0, score[loser] ?? 0, dW, dL)
.run();
// 시즌 패스 XP (실패해도 경기 결과에는 영향 없음)
await Promise.all([
awardXp(db, winner, PASS.LEAGUE_XP + PASS.LEAGUE_WIN_XP, now),
awardXp(db, loser, PASS.LEAGUE_XP, now),
]).catch((e) => console.error("xp", e));
return {
[winner]: { trDelta: dW, before: ratingView(w), after: ratingView(W), won: true },
[loser]: { trDelta: dL, before: ratingView(l), after: ratingView(L), won: false },
@@ -105,6 +111,9 @@ export async function recordCustom(db, { matchId, standings, size }, now = Date.
.bind(matchId, season, now, size, s.id, s.rank, s.wins),
);
if (stmts.length) await db.batch(stmts);
for (const st of standings) {
await awardXp(db, st.id, PASS.CUSTOM_XP + (st.rank === 1 ? PASS.CUSTOM_WIN_XP : 0), now).catch((e) => console.error("xp", e));
}
}
/** 일일 Cron: RD 감쇠 + 시즌 마감. */
@@ -141,6 +150,7 @@ export async function mergeGuestInto(db, guestId, userId) {
const { results } = await db.prepare("SELECT mode, best FROM solo_records WHERE user_id = ?").bind(guestId).all();
for (const rec of results) await submitSolo(db, userId, rec.mode, rec.best);
await db.batch([
...mergeShopStatements(db, guestId, userId),
db.prepare("UPDATE OR IGNORE matches SET p1 = ? WHERE p1 = ? AND mode = 'custom'").bind(userId, guestId),
db.prepare("DELETE FROM solo_records WHERE user_id = ?").bind(guestId),
db.prepare("DELETE FROM matches WHERE p1 = ? AND mode = 'custom'").bind(guestId),

View File

@@ -7,6 +7,8 @@ import {
BRAND, NICK_COOLDOWN_MS, NICK_RE, SOLO_MODES, isRoomCode, looksLikeGuestName, randomGuestName, randomRoomCode,
} from "./rules.js";
import { PASS, applyPurchase, awardXp, deleteShopStatements, equipBadge, passView, userItems } from "./shop.js";
export { GameRoomDO } from "./room.js";
export { MatchmakerDO } from "./matchmaker.js";
@@ -65,7 +67,7 @@ async function nicknameProblem(db, nick, selfId = null) {
async function playerInfo(env, u) {
const r = await getRating(env.DB, u.id);
const v = ratingView(r);
return { nick: u.nickname, guest: !!u.is_guest, tr: v.tr, rank: v.rank, r: r.glicko, rd: r.rd };
return { nick: u.nickname, guest: !!u.is_guest, tr: v.tr, rank: v.rank, r: r.glicko, rd: r.rd, badge: u.badge ?? null };
}
async function routeWs(req, env, url, u, ns, name, path = "/ws") {
@@ -172,7 +174,10 @@ async function handle(req, env) {
}
// 이하 인증 필요
const needAuth = path.startsWith("/api/me") || path === "/api/nickname" || path === "/api/solo" || path === "/api/rooms" || path.startsWith("/ws/");
const needAuth = path.startsWith("/api/me") || path === "/api/nickname" || path === "/api/solo" || path === "/api/rooms" ||
path === "/api/pass" || path === "/api/purchase" || path === "/api/badge" || path.startsWith("/ws/");
// 가짜 영수증(PLAY_VERIFY_FAKE)은 로컬 wrangler dev 에서만 받는다.
const local = url.hostname === "127.0.0.1" || url.hostname === "localhost";
const me = needAuth ? await authUser(req, env, url) : null;
if (needAuth && !me) return err("로그인이 필요합니다", 401);
@@ -188,8 +193,11 @@ async function handle(req, env) {
)
.bind(me.id)
.all();
const pass = await passView(db, env, me.id, { local });
return json({
user: publicUser(me),
items: await userItems(db, me.id),
pass: { season: pass.season, xp: pass.xp, level: pass.level, premium: pass.premium },
league: ratingView(r),
season: await getSeason(db),
solo: Object.fromEntries(solo.map((s) => [s.mode, s.best])),
@@ -207,6 +215,7 @@ async function handle(req, env) {
// 계정 삭제 (Play 정책: 계정을 만들 수 있으면 앱 안에서 삭제도 가능해야 한다)
if (path === "/api/me/delete" && req.method === "POST") {
await db.batch([
...deleteShopStatements(db, me.id),
db.prepare("DELETE FROM solo_records WHERE user_id = ?").bind(me.id),
db.prepare("DELETE FROM ratings WHERE user_id = ?").bind(me.id),
db.prepare("DELETE FROM matches WHERE p1 = ? AND mode = 'custom'").bind(me.id),
@@ -231,10 +240,30 @@ async function handle(req, env) {
if (path === "/api/solo" && req.method === "POST") {
const b = await body(req);
if (!SOLO_MODES.includes(b.mode) || !Number.isInteger(b.value) || b.value <= 0) return err("잘못된 기록");
if (!SOLO_MODES.includes(b.mode)) return err("잘못된 기록");
// 이어하기(보상형 광고)를 쓴 판: 기록·리더보드에는 넣지 않고 시즌 패스 XP 만 준다.
if (b.xpOnly === true) return json({ improved: false, xp: await awardXp(db, me.id, PASS.SOLO_XP, Date.now(), { solo: true }) });
if (!Number.isInteger(b.value) || b.value <= 0) return err("잘못된 기록");
// 최소 상식 검증: SPRINT 40줄 10초 미만은 불가능에 가깝다.
if (b.mode === "sprint" && b.value < 10_000) return err("기록이 비정상입니다");
return json(await submitSolo(db, me.id, b.mode, b.value));
const rec = await submitSolo(db, me.id, b.mode, b.value);
return json({ ...rec, xp: await awardXp(db, me.id, PASS.SOLO_XP, Date.now(), { solo: true }) });
}
// ── 시즌 패스 · 결제 · 배지 ──
if (path === "/api/pass") return json(await passView(db, env, me.id, { local }));
if (path === "/api/purchase" && req.method === "POST") {
const b = await body(req);
const r = await applyPurchase(db, env, me.id, b.productId, b.purchaseToken, { local });
return json(r.body, r.status);
}
if (path === "/api/badge" && req.method === "POST") {
const b = await body(req);
const p = await equipBadge(db, me.id, b.badge ?? null);
if (p) return err(p, 403);
return json({ user: publicUser(await getUser(db, me.id)) });
}
if (path.startsWith("/api/leaderboard")) {
@@ -242,25 +271,25 @@ async function handle(req, env) {
if (board === "league") {
const { results } = await db
.prepare(
`SELECT u.id, u.nickname, r.tr, r.rd, r.games, r.wins, r.total_games FROM ratings r JOIN users u ON u.id = r.user_id
`SELECT u.id, u.nickname, u.badge, r.tr, r.rd, r.games, r.wins, r.total_games FROM ratings r JOIN users u ON u.id = r.user_id
WHERE u.is_guest = 0 AND r.total_games >= 10 ORDER BY r.tr DESC LIMIT 100`,
)
.all();
return json({
board,
rows: results.map((r, i) => ({ pos: i + 1, id: r.id, nickname: r.nickname, ...ratingView({ ...r }) })),
rows: results.map((r, i) => ({ pos: i + 1, id: r.id, nickname: r.nickname, badge: r.badge ?? null, ...ratingView({ ...r }) })),
});
}
if (!SOLO_MODES.includes(board)) return err("unknown board");
const order = board === "sprint" ? "ASC" : "DESC";
const { results } = await db
.prepare(
`SELECT u.id, u.nickname, s.best FROM solo_records s JOIN users u ON u.id = s.user_id
`SELECT u.id, u.nickname, u.badge, s.best FROM solo_records s JOIN users u ON u.id = s.user_id
WHERE s.mode = ? AND u.is_guest = 0 ORDER BY s.best ${order} LIMIT 100`,
)
.bind(board)
.all();
return json({ board, rows: results.map((r, i) => ({ pos: i + 1, id: r.id, nickname: r.nickname, best: r.best })) });
return json({ board, rows: results.map((r, i) => ({ pos: i + 1, id: r.id, nickname: r.nickname, badge: r.badge ?? null, best: r.best })) });
}
if (path === "/api/season") return json(await getSeason(db));

88
server/src/play.js Normal file
View File

@@ -0,0 +1,88 @@
// Google Play Developer API 로 인앱 구매 영수증을 확인한다.
// 비밀값 PLAY_SA_KEY = 서비스 계정 JSON 키 전체 (Play Console 에서 "재무 데이터 보기" 권한을 준 계정).
export const PACKAGE_NAME = "kr.tkrmagid.tetrig";
const enc = new TextEncoder();
function b64url(data) {
const bytes = typeof data === "string" ? enc.encode(data) : new Uint8Array(data);
let s = "";
for (const b of bytes) s += String.fromCharCode(b);
return btoa(s).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
}
function pemToDer(pem) {
const body = pem.replace(/-----[^-]+-----/g, "").replace(/\s+/g, "");
const bin = atob(body);
const out = new Uint8Array(bin.length);
for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
return out.buffer;
}
let cached = null; // { token, exp, email }
async function accessToken(saJson) {
const sa = JSON.parse(saJson);
if (cached && cached.email === sa.client_email && cached.exp > Date.now() + 60_000) return cached.token;
const now = Math.floor(Date.now() / 1000);
const head = b64url(JSON.stringify({ alg: "RS256", typ: "JWT" }));
const claim = b64url(
JSON.stringify({
iss: sa.client_email,
scope: "https://www.googleapis.com/auth/androidpublisher",
aud: "https://oauth2.googleapis.com/token",
iat: now,
exp: now + 3600,
}),
);
const key = await crypto.subtle.importKey(
"pkcs8", pemToDer(sa.private_key), { name: "RSASSA-PKCS1-v1_5", hash: "SHA-256" }, false, ["sign"],
);
const sig = await crypto.subtle.sign("RSASSA-PKCS1-v1_5", key, enc.encode(`${head}.${claim}`));
const r = await fetch("https://oauth2.googleapis.com/token", {
method: "POST",
headers: { "Content-Type": "application/x-www-form-urlencoded" },
body: new URLSearchParams({
grant_type: "urn:ietf:params:oauth:grant-type:jwt-bearer",
assertion: `${head}.${claim}.${b64url(sig)}`,
}),
});
if (!r.ok) throw new Error(`google oauth ${r.status}`);
const j = await r.json();
cached = { token: j.access_token, exp: Date.now() + (j.expires_in ?? 3600) * 1000, email: sa.client_email };
return cached.token;
}
/**
* 반환: { valid:false } (없는/남의 앱 토큰) 또는
* { valid:true, purchaseState(0 구매·1 취소·2 대기), consumptionState(0 미소비·1 소비), orderId, purchaseTime }
* 네트워크/권한 오류는 throw (클라이언트는 나중에 다시 시도한다).
*
* 로컬 개발(wrangler dev)에서만 PLAY_VERIFY_FAKE=1 이면 "fake-<state>-..." 토큰을 받아 준다.
*/
export async function verifyPlayPurchase(env, productId, token, { local = false } = {}) {
if (local && env.PLAY_VERIFY_FAKE === "1" && token.startsWith("fake-")) {
const state = Number(token.split("-")[1]) || 0;
return { valid: true, purchaseState: state, consumptionState: 0, orderId: `GPA.FAKE-${token.slice(-6)}`, purchaseTime: Date.now() };
}
if (!env.PLAY_SA_KEY) throw new Error("PLAY_SA_KEY 미설정");
const at = await accessToken(env.PLAY_SA_KEY);
const url =
`https://androidpublisher.googleapis.com/androidpublisher/v3/applications/${PACKAGE_NAME}` +
`/purchases/products/${encodeURIComponent(productId)}/tokens/${encodeURIComponent(token)}`;
const r = await fetch(url, { headers: { Authorization: `Bearer ${at}` } });
if (r.status === 400 || r.status === 404 || r.status === 410) return { valid: false };
if (!r.ok) throw new Error(`play api ${r.status}`);
const j = await r.json();
return {
valid: true,
purchaseState: j.purchaseState ?? 0,
consumptionState: j.consumptionState ?? 0,
orderId: j.orderId ?? null,
purchaseTime: Number(j.purchaseTimeMillis) || Date.now(),
};
}
export function playVerifyConfigured(env, local = false) {
return !!env.PLAY_SA_KEY || (local && env.PLAY_VERIFY_FAKE === "1");
}

View File

@@ -98,7 +98,7 @@ export class RoomLogic {
const p = this.players.get(uid);
return {
id: p.uid, nick: p.nick, guest: p.guest, wins: p.wins, alive: p.alive, inRound: p.inRound,
connected: p.connected, rematch: p.rematch, tr: p.tr ?? null, rank: p.rank ?? null,
connected: p.connected, rematch: p.rematch, tr: p.tr ?? null, rank: p.rank ?? null, badge: p.badge ?? null,
};
}),
};
@@ -127,7 +127,7 @@ export class RoomLogic {
return { ok: true, rejoined: true };
}
const p = {
uid, nick: info.nick ?? "?", guest: !!info.guest, tr: info.tr ?? null, rank: info.rank ?? null,
uid, nick: info.nick ?? "?", guest: !!info.guest, tr: info.tr ?? null, rank: info.rank ?? null, badge: info.badge ?? null,
connected: true, disconnectedAt: 0,
wins: 0, inRound: false, alive: false, place: 0,
target: null, autoTarget: null, autoTargetAt: 0, lastAttacker: null,
@@ -485,6 +485,6 @@ export class RoomLogic {
function pickInfo(info) {
const o = {};
for (const k of ["nick", "guest", "tr", "rank"]) if (k in info) o[k] = info[k];
for (const k of ["nick", "guest", "tr", "rank", "badge"]) if (k in info) o[k] = info[k];
return o;
}

227
server/src/shop.js Normal file
View File

@@ -0,0 +1,227 @@
// 시즌 패스 XP · 꾸미기 아이템 · Play 결제 처리.
import { getSeason } from "./db.js";
import { playVerifyConfigured, verifyPlayPurchase } from "./play.js";
export const PRODUCTS = {
remove_ads: { consumable: false, items: [] },
supporter_pack: { consumable: false, items: ["skin:supporter", "badge:supporter"] },
season_pass: { consumable: true, items: [] },
};
export const PASS = {
XP_PER_LEVEL: 100,
MAX_LEVEL: 30,
SOLO_XP: 10,
SOLO_MIN_GAP_MS: 20_000, // 솔로 XP 는 20초에 한 번만 (빈 판 연타 방지)
CUSTOM_XP: 20,
CUSTOM_WIN_XP: 10,
LEAGUE_XP: 25,
LEAGUE_WIN_XP: 15,
};
// {n} 은 시즌 번호. 아이템 ID 는 앱 Catalog 와 같아야 한다.
const TIERS = [
{ level: 1, premium: "board:oxide" },
{ level: 5, free: "skin:chalk" },
{ level: 8, premium: "skin:outline" },
{ level: 12, free: "board:nogrid" },
{ level: 15, premium: "skin:signal" },
{ level: 20, free: "skin:mono" },
{ level: 22, premium: "board:moss" },
{ level: 25, premium: "badge:s{n}_pass" },
{ level: 30, free: "badge:s{n}_finish", premium: "badge:s{n}_elite" },
];
export function passTiers(season) {
const sub = (x) => (x ? x.replace("{n}", String(season)) : null);
return TIERS.map((t) => ({ level: t.level, free: sub(t.free), premium: sub(t.premium) }));
}
export const levelFor = (xp) => Math.min(PASS.MAX_LEVEL, Math.floor(Math.max(0, xp) / PASS.XP_PER_LEVEL) + 1);
/** (fromLevel, toLevel] 구간에서 새로 받는 보상. premium 이면 프리미엄 트랙 포함. */
export function rewardsBetween(season, fromLevel, toLevel, premium) {
const out = [];
for (const t of passTiers(season)) {
if (t.level <= fromLevel || t.level > toLevel) continue;
if (t.free) out.push(t.free);
if (premium && t.premium) out.push(t.premium);
}
return out;
}
/** 프리미엄을 산 순간: 지금 레벨까지의 프리미엄 보상을 한꺼번에. */
export function premiumBackfill(season, level) {
return passTiers(season).filter((t) => t.premium && t.level <= level).map((t) => t.premium);
}
async function grantItems(db, uid, items, source, now = Date.now()) {
if (!items.length) return;
await db.batch(
items.map((it) =>
db.prepare("INSERT OR IGNORE INTO user_items(user_id, item, source, created_at) VALUES (?, ?, ?, ?)").bind(uid, it, source, now),
),
);
}
async function passRow(db, uid, season) {
return (await db.prepare("SELECT * FROM season_xp WHERE user_id = ? AND season = ?").bind(uid, season).first()) ?? {
user_id: uid, season, xp: 0, premium: 0, last_solo_at: null,
};
}
/** XP 를 더하고, 새로 닿은 레벨의 보상을 준다. 반환 { xp, level, gained:[아이템] } */
export async function awardXp(db, uid, amount, now = Date.now(), { solo = false } = {}) {
const season = (await getSeason(db, now)).n;
const row = await passRow(db, uid, season);
if (solo && row.last_solo_at && now - row.last_solo_at < PASS.SOLO_MIN_GAP_MS) {
return { xp: row.xp, level: levelFor(row.xp), gained: [], throttled: true };
}
const xp = row.xp + amount;
await db
.prepare(
`INSERT INTO season_xp(user_id, season, xp, premium, last_solo_at) VALUES (?1, ?2, ?3, 0, ?4)
ON CONFLICT(user_id, season) DO UPDATE SET xp = xp + ?5, last_solo_at = COALESCE(?4, last_solo_at)`,
)
.bind(uid, season, xp, solo ? now : null, amount)
.run();
const gained = rewardsBetween(season, levelFor(row.xp), levelFor(xp), !!row.premium);
await grantItems(db, uid, gained, `pass:s${season}`, now);
return { xp, level: levelFor(xp), gained };
}
export async function passView(db, env, uid, { local = false } = {}) {
const s = await getSeason(db);
const row = await passRow(db, uid, s.n);
return {
season: s.n,
endsAt: s.endsAt,
xp: row.xp,
level: levelFor(row.xp),
maxLevel: PASS.MAX_LEVEL,
xpPerLevel: PASS.XP_PER_LEVEL,
premium: !!row.premium,
purchasable: playVerifyConfigured(env, local),
tiers: passTiers(s.n),
};
}
export async function userItems(db, uid) {
const { results } = await db.prepare("SELECT item FROM user_items WHERE user_id = ? ORDER BY item").bind(uid).all();
return results.map((r) => r.item);
}
/** 장착 배지 검증: 가진 배지만. null 이면 해제. */
export async function equipBadge(db, uid, badge) {
if (badge === null || badge === undefined || badge === "") {
await db.prepare("UPDATE users SET badge = NULL WHERE id = ?").bind(uid).run();
return null;
}
if (typeof badge !== "string" || !/^[a-z0-9_]{1,24}$/.test(badge)) return "잘못된 배지입니다";
const own = await db.prepare("SELECT 1 FROM user_items WHERE user_id = ? AND item = ?").bind(uid, `badge:${badge}`).first();
if (!own) return "가지고 있지 않은 배지입니다";
await db.prepare("UPDATE users SET badge = ? WHERE id = ?").bind(badge, uid).run();
return null;
}
/** 배지를 잃었으면(구매 이전 등) 장착도 푼다. */
async function dropLostBadge(db, uid) {
await db
.prepare(
`UPDATE users SET badge = NULL WHERE id = ?1 AND badge IS NOT NULL
AND NOT EXISTS (SELECT 1 FROM user_items WHERE user_id = ?1 AND item = 'badge:' || users.badge)`,
)
.bind(uid)
.run();
}
/**
* Play 구매 확인 → 권한 부여. 반환 { status, body }.
* - 200 { ok, consume, items } : 적용됨 (consume=true 면 클라이언트가 소비해도 된다)
* - 409 : 이미 다른 계정에 적용된 시즌 패스 / 이번 시즌 패스를 이미 가짐 (소비하지 말 것)
* - 410 : 취소·환불된 구매, 400 : 잘못된 요청, 425 : 결제 대기 중, 503 : 확인 서버 미설정·Google 오류
*/
export async function applyPurchase(db, env, uid, productId, token, { now = Date.now(), local = false } = {}) {
const prod = PRODUCTS[productId];
if (!prod || typeof token !== "string" || token.length < 10 || token.length > 4096) {
return { status: 400, body: { error: "잘못된 구매 정보입니다" } };
}
if (!playVerifyConfigured(env, local)) return { status: 503, body: { error: "결제 확인 서버가 아직 준비되지 않았습니다" } };
const existing = await db.prepare("SELECT * FROM purchases WHERE token = ?").bind(token).first();
if (existing && existing.product !== productId) return { status: 400, body: { error: "잘못된 구매 정보입니다" } };
if (existing && existing.user_id === uid) {
return { status: 200, body: { ok: true, consume: prod.consumable, items: await userItems(db, uid) } };
}
if (existing && prod.consumable) return { status: 409, body: { error: "이미 다른 계정에 적용된 구매입니다" } };
let v;
try {
v = await verifyPlayPurchase(env, productId, token, { local });
} catch (e) {
console.error("play verify", e);
return { status: 503, body: { error: "결제 확인에 실패했습니다. 잠시 뒤 자동으로 다시 시도합니다" } };
}
if (!v.valid) return { status: 400, body: { error: "확인할 수 없는 구매입니다" } };
if (v.purchaseState === 2) return { status: 425, body: { error: "결제 대기 중입니다" } };
if (v.purchaseState !== 0) return { status: 410, body: { error: "취소되었거나 환불된 구매입니다" } };
const season = (await getSeason(db, now)).n;
const src = `purchase:${token.slice(0, 24)}`;
if (prod.consumable) {
if (v.consumptionState === 1) return { status: 410, body: { error: "이미 사용된 구매입니다" } };
const row = await passRow(db, uid, season);
if (row.premium) return { status: 409, body: { error: "이번 시즌 패스를 이미 가지고 있습니다. 이 구매는 다음 시즌에 적용됩니다" } };
await db.batch([
db.prepare("INSERT INTO purchases(token, user_id, product, order_id, season, created_at) VALUES (?, ?, ?, ?, ?, ?)")
.bind(token, uid, productId, v.orderId, season, now),
db.prepare(
`INSERT INTO season_xp(user_id, season, xp, premium) VALUES (?1, ?2, 0, 1)
ON CONFLICT(user_id, season) DO UPDATE SET premium = 1`,
).bind(uid, season),
]);
await grantItems(db, uid, premiumBackfill(season, levelFor(row.xp)), `pass:s${season}`, now);
} else {
if (existing) {
// 같은 Google 계정의 비소모성 구매를 다른 게임 계정에서 복원 → 가장 최근 계정으로 옮긴다 (동시 공유 방지).
await db.batch([
db.prepare("DELETE FROM user_items WHERE user_id = ? AND source = ?").bind(existing.user_id, src),
db.prepare("UPDATE purchases SET user_id = ?, created_at = ? WHERE token = ?").bind(uid, now, token),
]);
await dropLostBadge(db, existing.user_id);
} else {
await db
.prepare("INSERT INTO purchases(token, user_id, product, order_id, season, created_at) VALUES (?, ?, ?, ?, NULL, ?)")
.bind(token, uid, productId, v.orderId, now)
.run();
}
await grantItems(db, uid, prod.items, src, now);
}
return { status: 200, body: { ok: true, consume: prod.consumable, items: await userItems(db, uid) } };
}
/** 게스트 → 계정 병합 때 시즌 패스·아이템·구매를 옮긴다 (db.mergeGuestInto 에서 호출). */
export function mergeShopStatements(db, guestId, userId) {
return [
db.prepare(
`INSERT INTO season_xp(user_id, season, xp, premium, last_solo_at)
SELECT ?2, season, xp, premium, last_solo_at FROM season_xp WHERE user_id = ?1 AND true
ON CONFLICT(user_id, season) DO UPDATE SET xp = season_xp.xp + excluded.xp, premium = MAX(season_xp.premium, excluded.premium)`,
).bind(guestId, userId),
db.prepare("INSERT OR IGNORE INTO user_items(user_id, item, source, created_at) SELECT ?2, item, source, created_at FROM user_items WHERE user_id = ?1")
.bind(guestId, userId),
db.prepare("UPDATE purchases SET user_id = ?2 WHERE user_id = ?1").bind(guestId, userId),
db.prepare("DELETE FROM season_xp WHERE user_id = ?").bind(guestId),
db.prepare("DELETE FROM user_items WHERE user_id = ?").bind(guestId),
];
}
export function deleteShopStatements(db, uid) {
return [
db.prepare("DELETE FROM season_xp WHERE user_id = ?").bind(uid),
db.prepare("DELETE FROM user_items WHERE user_id = ?").bind(uid),
// 구매 기록을 지워야 같은 Google 계정으로 새 게임 계정에 다시 복원할 수 있다.
db.prepare("DELETE FROM purchases WHERE user_id = ?").bind(uid),
];
}

36
server/test/shop.test.js Normal file
View File

@@ -0,0 +1,36 @@
import { test } from "node:test";
import assert from "node:assert/strict";
import { PASS, levelFor, passTiers, premiumBackfill, rewardsBetween } from "../src/shop.js";
test("레벨: 100 XP 마다 1레벨, 30 상한", () => {
assert.equal(levelFor(0), 1);
assert.equal(levelFor(99), 1);
assert.equal(levelFor(100), 2);
assert.equal(levelFor(2900), 30);
assert.equal(levelFor(999_999), PASS.MAX_LEVEL);
});
test("시즌 번호가 배지 ID 에 들어간다", () => {
const last = passTiers(3).find((t) => t.level === 30);
assert.equal(last.free, "badge:s3_finish");
assert.equal(last.premium, "badge:s3_elite");
});
test("레벨 구간 보상: 무료 트랙만 / 프리미엄 포함", () => {
assert.deepEqual(rewardsBetween(1, 4, 5, false), ["skin:chalk"]);
assert.deepEqual(rewardsBetween(1, 1, 8, false), ["skin:chalk"]);
assert.deepEqual(rewardsBetween(1, 1, 8, true), ["skin:chalk", "skin:outline"]);
assert.deepEqual(rewardsBetween(1, 5, 5, true), []); // 같은 레벨이면 없음
});
test("프리미엄 구매 시 지난 레벨 보상 소급", () => {
assert.deepEqual(premiumBackfill(1, 1), ["board:oxide"]);
assert.deepEqual(premiumBackfill(2, 16), ["board:oxide", "skin:outline", "skin:signal"]);
});
test("만렙까지 받는 보상 = 전체 트랙", () => {
const free = rewardsBetween(1, 0, 30, false);
const all = rewardsBetween(1, 0, 30, true);
assert.equal(free.length, 4);
assert.equal(all.length, 4 + 6);
});

1
store/_redirects Normal file
View File

@@ -0,0 +1 @@
/r/* /r/ 200

View File

@@ -44,11 +44,21 @@ TETRIG
■ 기록
· 리그·SPRINT·TIME ATTACK·ENDLESS 리더보드, 프로필 전적
· 결과 화면을 이미지 한 장으로 바로 공유
■ 시즌 패스 · 꾸미기
· 게임을 할 때마다 XP 가 쌓이고, 레벨 보상으로 블록 스킨·보드 테마·배지를 받습니다
· 프리미엄 패스를 사면 프리미엄 트랙 보상까지 (지난 레벨 보상도 바로 지급)
· 꾸미기는 보는 재미만 바꿉니다. 실력·레이팅에 영향을 주는 아이템은 없습니다
■ 친구 초대
· 커스텀 방에서 초대 링크를 보내면 친구는 링크를 눌러 바로 같은 방에 들어옵니다
■ 어떤 화면에서든
· 스마트폰, 갤럭시 폴드·플립, 태블릿, 가로 화면까지 배치가 자동으로 맞춰집니다. 왼손 배치·큰 버튼 옵션 제공.
게임 플레이 중에는 광고가 나오지 않습니다. 계정은 앱 안 프로필에서 언제든 삭제할 수 있습니다.
게임 플레이 중에는 광고가 나오지 않습니다. 광고 1편을 보고 30분 동안 전면 광고를 끌 수 있고, '광고 제거'를 사면 광고가 모두 사라집니다.
계정은 앱 안 프로필에서 언제든 삭제할 수 있습니다.
배치 10경기를 끝내보세요.
@@ -75,7 +85,7 @@ TETRIG은 개인이 만든 앱입니다. Tetris Holding LLC 및 관련 회사와
---
## 데이터 보안(Data safety) 설문 답안 (v2.1.0~, 온라인·광고 추가 후)
## 데이터 보안(Data safety) 설문 답안 (v2.2.0~, 결제·미디에이션 추가 후)
- 사용자 데이터를 수집하거나 공유하나요? → **예**
- 전송 중 암호화 → **예** (HTTPS/WSS)
@@ -84,15 +94,31 @@ TETRIG은 개인이 만든 앱입니다. Tetris Holding LLC 및 관련 회사와
- 개인 정보 > 이메일 주소: 수집(선택), 목적 = 계정 관리. 공유 안 함
- 개인 정보 > 사용자 ID(닉네임·내부 ID): 수집(필수), 목적 = 앱 기능·계정 관리. 공유 안 함
- 앱 활동 > 기타 사용자 생성 콘텐츠/게임 기록: 수집, 목적 = 앱 기능. 공유 안 함
- 기기 또는 기타 ID > 광고 ID: 수집·**공유**(Google AdMob), 목적 = 광고
- 기기 또는 기타 ID > 광고 ID: 수집·**공유**(Google AdMob, AppLovin, Pangle), 목적 = 광고
- 금융 정보 > 구매 내역: 수집(인앱 구매 시), 목적 = 앱 기능(구매 확인·권한 지급). 공유 안 함. 결제 수단 정보는 Google Play 가 처리하고 앱은 받지 않음
- 앱 활동 > 앱 상호작용(시즌 패스 XP·꾸미기 아이템): 수집, 목적 = 앱 기능. 공유 안 함
- 계정 삭제 URL(웹): `https://tetrig.pages.dev/privacy` (4항 — 이메일 삭제 요청 안내)
## 광고 (AdMob)
- 앱 콘텐츠 > 광고: **예, 광고 포함**
- 광고 단위 ID 는 `app/gradle.properties` 의 `admob*` 값. 비어 있으면 Google 테스트 광고.
- 노출 규칙: 메인·커스텀 로비 하단 배너, 모든 결과 화면 300×250, 결과 → 다음 행동 사이 전면(3판당 1회, 세션 첫 판 제외). 플레이 화면 광고 0.
- `app-ads.txt`: AdMob 에서 받은 한 줄을 개발자 웹사이트 루트에 올린다.
- 노출 규칙: 메인·커스텀 로비 하단 배너, 모든 결과 화면 300×250, 결과 → 다음 행동 사이 전면(마지막 전면 뒤 3판 이상 + 세션 첫 판 제외, 판 수는 앱을 꺼도 이어서 셈). 플레이 화면 광고 0.
- 보상형(사용자가 고를 때만): 30분 전면 끄기 · TIME ATTACK 이어하기(1판 1회, 기록 미반영) · 리소 스킨/흑연 보드 해금.
- 광고 제거·서포터 팩 구매자는 배너·결과·전면이 모두 꺼지고 보상형만 선택지로 남는다.
- 미디에이션: AppLovin·Pangle 어댑터 포함. AdMob 콘솔 > 미디에이션에서 그룹을 만들어야 입찰에 들어온다.
- `app-ads.txt`: AdMob 한 줄 + AppLovin·Pangle 이 주는 줄을 개발자 웹사이트 루트에 올린다.
## 인앱 상품 (Play Console > 수익 창출 > 인앱 상품)
| 상품 ID | 이름 | 가격 | 종류 |
|---|---|---|---|
| `remove_ads` | 광고 제거 | 3,300원 | 일회성(비소모) |
| `supporter_pack` | 서포터 팩 (광고 제거 + 서포터 스킨 + SUPPORTER 배지) | 5,900원 | 일회성(비소모) |
| `season_pass` | 시즌 패스 (이번 시즌 프리미엄 트랙) | 4,900원 | 일회성(소모, 시즌마다 다시 구매) |
- 앱은 Play 가 준 가격을 그대로 표시하고, 상품이 없으면 구매 버튼을 끈다.
- 시즌 패스·배지는 서버가 Google Play Developer API 로 영수증을 확인한 뒤 준다 (`wrangler secret put PLAY_SA_KEY`, 서비스 계정 JSON). 설정 전에는 시즌 패스 구매 버튼이 "준비 중"으로 숨겨진다.
## 콘텐츠 등급 설문

View File

@@ -25,11 +25,12 @@
<body>
<main>
<h1><span class="o">TET</span>RIG 개인정보처리방침</h1>
<p class="meta">최종 수정일: 2026-11-04 · 앱 패키지: kr.tkrmagid.tetrig</p>
<p class="meta">최종 수정일: 2026-11-05 · 앱 패키지: kr.tkrmagid.tetrig</p>
<div class="panel">
<p><strong>요약:</strong> 온라인 대전(커스텀 방·리그전)과 리더보드를 위해 게임 계정 정보와 경기 기록을 서버에 저장합니다.
무료 운영을 위해 Google AdMob 광고를 표시하며, 이 과정에서 광고 ID 등 기기 정보가 Google 에 전송될 수 있습니다.
무료 운영을 위해 Google AdMob 광고(및 AdMob 이 중개하는 AppLovin·Pangle 광고)를 표시하며, 이 과정에서 광고 ID 등 기기 정보가 광고 회사에 전송될 수 있습니다.
광고 제거·서포터 팩·시즌 패스를 사면 결제는 Google Play 가 처리하고, 저희는 카드 정보를 받지 않습니다.
솔로 모드는 계정 없이도 쓸 수 있고, 계정은 앱 안에서 언제든 삭제할 수 있습니다.</p>
</div>
@@ -39,30 +40,37 @@
<li><strong>이메일 계정(선택)</strong>: 이메일 주소, 비밀번호(PBKDF2 해시로만 저장, 원문 저장 안 함), 닉네임. 로그인과 기록 이전에 씁니다.</li>
<li><strong>게임 기록</strong>: 솔로 최고 기록, 리그 레이팅(Glicko-2·TR)·전적, 커스텀 방 순위. 리더보드·프로필 표시와 매칭에 씁니다.</li>
<li><strong>대전 중 데이터</strong>: 보드 상태, 공격량 등 경기 진행 신호. 실시간 중계와 부정행위 방지에만 쓰며 경기가 끝나면 결과만 남습니다.</li>
<li><strong>시즌 패스·꾸미기</strong>: 시즌별 경험치(XP), 받은 꾸미기 아이템(블록 스킨·보드 테마·배지), 장착한 배지. 장착한 배지는 다른 플레이어에게 닉네임과 함께 보입니다.</li>
<li><strong>구매 기록</strong>: 인앱 구매 시 Google Play 가 발급한 구매 토큰과 주문 번호, 상품 ID, 구매 시각. 구매가 진짜인지 Google Play Developer API 로 확인하고 권한(배지·시즌 패스)을 주는 데만 씁니다. 결제 수단·카드 정보는 받지 않습니다.</li>
</ul>
<h2>2. 광고 (Google AdMob)</h2>
<p>메인 화면·커스텀 로비 하단 배너, 결과 화면 광고, 그리고 3판에 한 번 결과 화면을 나갈 때 전면 광고를 표시합니다. 게임 플레이 중에는 광고가 나오지 않습니다.
광고 제공을 위해 Google 이 광고 ID, IP 주소, 기기·앱 정보를 수집·처리할 수 있습니다. 유럽경제지역·영국 등에서는 처음 실행 시 동의 화면이 표시됩니다.
Google 의 처리 방식: <a href="https://policies.google.com/technologies/partner-sites">https://policies.google.com/technologies/partner-sites</a>.
기기 설정 &gt; Google &gt; 광고에서 광고 ID 를 재설정하거나 삭제할 수 있습니다.</p>
<p>메인 화면·커스텀 로비 하단 배너, 결과 화면 광고, 그리고 마지막 전면 광고 뒤 3판 이상 지났을 때 결과 화면을 나가면 전면 광고를 표시합니다. 게임 플레이 중에는 광고가 나오지 않습니다.
보상형 광고(30분간 전면 광고 끄기, TIME ATTACK 이어하기, 스킨 해금)는 사용자가 직접 고를 때만 나옵니다.
광고 제공을 위해 Google 과, Google 이 입찰을 중개하는 광고 네트워크(AppLovin, Pangle)가 광고 ID, IP 주소, 기기·앱 정보를 수집·처리할 수 있습니다. 유럽경제지역·영국 등에서는 처음 실행 시 동의 화면이 표시됩니다.
Google 의 처리 방식: <a href="https://policies.google.com/technologies/partner-sites">https://policies.google.com/technologies/partner-sites</a>,
AppLovin: <a href="https://www.applovin.com/privacy/">https://www.applovin.com/privacy/</a>,
Pangle: <a href="https://www.pangleglobal.com/privacy">https://www.pangleglobal.com/privacy</a>.
기기 설정 &gt; Google &gt; 광고에서 광고 ID 를 재설정하거나 삭제할 수 있습니다. 광고 제거 상품을 사면 배너·결과·전면 광고가 모두 사라집니다.</p>
<h2>3. 보관과 처리 위치</h2>
<p>서버는 Cloudflare(Workers·D1)에서 운영되며 전송 구간은 모두 HTTPS/WSS 로 암호화됩니다. 계정을 삭제하기 전까지 보관하고, 삭제하면 즉시 지웁니다.
리그 경기 결과에는 상대 플레이어의 전적 보존을 위해 개인을 식별할 수 없는 내부 ID 와 점수만 남습니다.</p>
<h2>4. 계정 삭제</h2>
<p>앱 &gt; 프로필 &gt; <strong>계정 삭제</strong>를 누르면 계정, 이메일, 비밀번호 해시, 닉네임, 레이팅, 솔로 기록, 커스텀 전적이 즉시 삭제됩니다.
<p>앱 &gt; 프로필 &gt; <strong>계정 삭제</strong>를 누르면 계정, 이메일, 비밀번호 해시, 닉네임, 레이팅, 솔로 기록, 커스텀 전적, 시즌 패스 XP·꾸미기 아이템, 구매 기록이 즉시 삭제됩니다.
Google Play 에서 산 광고 제거·서포터 팩은 Google 계정에 남아 있어, 새 계정에서 '구매 복원'으로 다시 받을 수 있습니다.
앱을 쓸 수 없는 경우 가입한 이메일로 <a href="mailto:tkrmagid@gmail.com?subject=TETRIG%20계정%20삭제%20요청">tkrmagid@gmail.com</a> 에 삭제를 요청하면 7일 안에 처리합니다.</p>
<h2>5. 기기에 저장되는 정보</h2>
<p>로그인 토큰, 솔로 최고 기록, 설정값(고스트·왼손 배치·큰 버튼)이 기기 안(SharedPreferences)에 저장되며 앱을 삭제하면 함께 지워집니다.</p>
<p>로그인 토큰, 솔로 최고 기록, 설정값(고스트·왼손 배치·큰 버튼), 장착한 스킨, 광고 횟수(전면 광고 간격 계산용), 구매·보상 상태가 기기 안(SharedPreferences)에 저장되며 앱을 삭제하면 함께 지워집니다.
결과 이미지를 공유할 때 만든 그림은 앱 캐시에만 잠시 저장됩니다.</p>
<h2>6. 권한</h2>
<p>인터넷·네트워크 상태 권한만 사용합니다(온라인 대전과 광고). 위치·카메라·마이크·연락처 권한은 요청하지 않습니다.</p>
<h2>7. 제3자 제공</h2>
<p>광고를 위한 Google AdMob 외에는 어떤 제3자에게도 정보를 판매·제공하지 않습니다. 분석·추적 SDK 는 쓰지 않습니다.</p>
<p>광고를 위한 Google AdMob 과 미디에이션 광고 네트워크(AppLovin, Pangle), 결제를 위한 Google Play 외에는 어떤 제3자에게도 정보를 판매·제공하지 않습니다. 분석·추적 SDK 는 쓰지 않습니다.</p>
<h2>8. 아동</h2>
<p>만 14세 미만 아동을 대상으로 하지 않으며, 그 사실을 알게 되면 해당 계정을 삭제합니다.</p>
@@ -73,11 +81,12 @@
<hr>
<h1><span class="o">TET</span>RIG Privacy Policy</h1>
<p class="meta">Last updated: 2026-11-04 · Package: kr.tkrmagid.tetrig</p>
<p class="meta">Last updated: 2026-11-05 · Package: kr.tkrmagid.tetrig</p>
<div class="panel">
<p><strong>Summary:</strong> To provide online matches (custom rooms, ranked league) and leaderboards, we store your game account and match records on our server.
The app shows Google AdMob ads, which may send device information such as the advertising ID to Google.
The app shows Google AdMob ads (including AppLovin and Pangle ads mediated by AdMob), which may send device information such as the advertising ID to these ad networks.
In-app purchases (remove ads, supporter pack, season pass) are processed by Google Play; we never receive card details.
Solo modes work without an account, and you can delete your account in the app at any time.</p>
</div>
@@ -87,18 +96,21 @@
<li><strong>Email account (optional)</strong>: email, password (stored only as a PBKDF2 hash), nickname.</li>
<li><strong>Game records</strong>: solo bests, league rating and match history, custom room placements.</li>
<li><strong>In-match signals</strong>: board state and attacks, used only to relay the live match and prevent cheating.</li>
<li><strong>Season pass and cosmetics</strong>: seasonal XP, unlocked cosmetics and your equipped badge (visible to other players next to your nickname).</li>
<li><strong>Purchase records</strong>: the Google Play purchase token, order ID, product ID and time, used only to verify the purchase with the Google Play Developer API and grant the item.</li>
</ul>
<h2>2. Advertising (Google AdMob)</h2>
<p>Banner ads on the home screen and custom lobby, an ad on result screens, and an interstitial at most once every three games when leaving a result screen. No ads during gameplay.
Google may collect the advertising ID, IP address and device/app information to serve ads. Users in the EEA/UK see a consent form on first launch.
<p>Banner ads on the home screen and custom lobby, an ad on result screens, and an interstitial when leaving a result screen once at least three games have passed since the last one. No ads during gameplay.
Rewarded ads (30 minutes without interstitials, TIME ATTACK continue, skin unlock) are shown only when you choose them.
Google and the mediated networks (AppLovin, Pangle) may collect the advertising ID, IP address and device/app information to serve ads. Users in the EEA/UK see a consent form on first launch.
See <a href="https://policies.google.com/technologies/partner-sites">https://policies.google.com/technologies/partner-sites</a>.</p>
<h2>3. Storage</h2>
<p>The server runs on Cloudflare (Workers, D1); all traffic is encrypted (HTTPS/WSS). Data is kept until you delete your account.</p>
<h2>4. Account deletion</h2>
<p>In the app: Profile &gt; <strong>계정 삭제 (Delete account)</strong> deletes your account, email, password hash, nickname, rating, solo records and custom history immediately.
<p>In the app: Profile &gt; <strong>계정 삭제 (Delete account)</strong> deletes your account, email, password hash, nickname, rating, solo records, custom history, season pass XP, cosmetics and purchase records immediately.
If you cannot use the app, email <a href="mailto:tkrmagid@gmail.com?subject=TETRIG%20account%20deletion">tkrmagid@gmail.com</a> from your registered address; requests are handled within 7 days.</p>
<h2>5. Contact</h2>

61
store/room.html Normal file
View File

@@ -0,0 +1,61 @@
<!DOCTYPE html>
<html lang="ko">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>TETRIG 커스텀 방 초대</title>
<meta property="og:title" content="TETRIG 커스텀 방 초대">
<meta property="og:description" content="링크를 누르면 앱에서 바로 방에 들어갑니다. 인원 제한 없는 실시간 난투!">
<meta property="og:image" content="https://tetrig.pages.dev/icon-512.png">
<meta name="robots" content="noindex">
<style>
:root{ --ink:#17161B; --bone:#EDE7DA; --paper:#E1D9C7; --sub:#6E6A5E; --safety:#FF4E11; }
*{ box-sizing:border-box; margin:0; padding:0; }
body{ background:var(--bone); color:var(--ink); font-family:ui-monospace,'Menlo',monospace; padding:36px 20px; }
main{ max-width:460px; margin:0 auto; }
h1{ font-size:34px; font-style:italic; font-weight:900; }
h1 .o{ color:var(--safety); }
.bar{ width:150px; height:10px; background:var(--ink); margin:6px 0 28px; }
.code{ background:var(--ink); color:var(--safety); border:2px solid var(--ink); box-shadow:5px 5px 0 var(--ink);
text-align:center; padding:18px; margin-bottom:22px;
clip-path:polygon(0 0,100% 0,100% calc(100% - 14px),calc(100% - 14px) 100%,0 100%); }
.code small{ display:block; color:#8D8A80; font-size:12px; margin-bottom:4px; }
.code b{ font-size:44px; font-style:italic; font-weight:900; letter-spacing:4px; }
a.btn{ display:block; text-align:center; text-decoration:none; color:var(--ink); font-weight:700; font-size:15px;
border:2px solid var(--ink); box-shadow:4px 4px 0 var(--ink); padding:14px; margin-bottom:14px; background:var(--bone); }
a.btn.go{ background:var(--safety); }
p{ font-size:13px; line-height:1.7; color:var(--sub); margin-top:8px; }
.bad{ color:var(--safety); font-weight:700; }
</style>
</head>
<body>
<main>
<h1><span class="o">TET</span>RIG</h1>
<div class="bar"></div>
<div id="ok" hidden>
<div class="code"><small>커스텀 방 초대 코드</small><b id="code">------</b></div>
<a class="btn go" id="open" href="#">앱에서 바로 들어가기</a>
<a class="btn" id="store" href="https://play.google.com/store/apps/details?id=kr.tkrmagid.tetrig">Google Play 에서 TETRIG 받기</a>
<p>앱이 설치돼 있으면 위 버튼으로 이 방에 바로 들어갑니다. 앱이 없으면 Play 스토어로 이동합니다.<br>
직접 들어가려면 앱 &gt; 커스텀 &gt; 참가하기에서 코드를 입력하세요.</p>
</div>
<p id="bad" class="bad" hidden>초대 링크가 올바르지 않습니다.</p>
</main>
<script>
const m = /^\/r\/([A-Za-z0-9]{6})\/?$/.exec(location.pathname);
if (!m) {
document.getElementById('bad').hidden = false;
} else {
const code = m[1].toUpperCase();
const play = 'https://play.google.com/store/apps/details?id=kr.tkrmagid.tetrig';
document.getElementById('ok').hidden = false;
document.getElementById('code').textContent = code;
document.title = 'TETRIG 방 ' + code + ' 초대';
// Android Chrome: 앱이 있으면 앱으로, 없으면 Play 스토어로
document.getElementById('open').href =
'intent://tetrig.pages.dev/r/' + code + '#Intent;scheme=https;package=kr.tkrmagid.tetrig;S.browser_fallback_url=' +
encodeURIComponent(play) + ';end';
}
</script>
</body>
</html>