wip(bunsik): 경제 개편 공용 로직 — 업그레이드 갈래, 의자·테이블 배치와 길 찾기(Floor), 알바생 역할·시급, 손님 러시·홍보·쫓아내기 로직, 서버↔클라이언트 약속(NETWORK.md)
서버·클라이언트는 다음 커밋에서 새 구조로 옮깁니다(이 커밋만으로는 빌드 검사가 통과하지 않음). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
82
bunsik-tycoon/NETWORK.md
Normal file
82
bunsik-tycoon/NETWORK.md
Normal file
@@ -0,0 +1,82 @@
|
||||
# 서버 ↔ 클라이언트 약속 (2026-10-14 개편)
|
||||
|
||||
서버는 상태를 **속성(Attribute)** 으로 내보내고, 클라이언트는 `Remotes.Action:FireServer(kind, arg)` 로 요청합니다.
|
||||
알림은 `Remotes.Notify:FireClient(player, key, args)` 이고, 글자는 클라이언트가 `Locale.t(lang, key, args)` 로 씁니다.
|
||||
경제·배치 규칙은 공용 모듈(`src/shared/Economy.luau`, `Shop.luau`, `Floor.luau`)이 원본입니다. 클라이언트는 같은 모듈로 값·미리보기를 계산하고, 서버가 다시 검사합니다.
|
||||
|
||||
## 플레이어 속성 (Player)
|
||||
|
||||
| 속성 | 형 | 뜻 |
|
||||
|---|---|---|
|
||||
| Ready | bool | 세이브 로드 끝 |
|
||||
| Plot | number | 내 부지 번호 |
|
||||
| Money, Earned | number | 돈, 지금까지 번 돈 |
|
||||
| Levels | string | 갈래 레벨 `"Stage=1,Menu=2,Price=0,Speed=1,Stove=0,Tray=0,Staff=1"` (Economy.TRACK_ORDER 순서). `Shared.Codec.decodeMap` 로 읽음 |
|
||||
| Stage | number | 건물 단계 1 포장마차, 2 실내, 3 2층 |
|
||||
| Seats, Tables | number | 놓은 의자 수(= 손님 자리 수), 테이블 수 |
|
||||
| Layout | string | 배치 JSON(`Floor.Layout` 모양). `HttpService:JSONDecode` 후 `Floor.clean` |
|
||||
| Staff | string | 고용한 알바 수 `"Cook=1,Server=0,Promoter=0"` |
|
||||
| Strike | bool | 시급이 모자라 알바생이 쉬는 중 |
|
||||
| Wage | number | 1분마다 주는 시급 합계 |
|
||||
| RushUntil | number | 손님 러시가 끝나는 서버 시각(`workspace:GetServerTimeNow()` 기준, 0이면 없음) |
|
||||
| PromoteAt | number | 다음 홍보를 할 수 있는 서버 시각(광고 없이) |
|
||||
| PromoteAdAt | number | 광고를 보고 홍보할 수 있는 서버 시각 |
|
||||
| KickCredits | number | 남은 "손님 쫓아내기" 횟수(유료로 산 것) |
|
||||
| ShopName | string | 내가 정한 가게 이름 원문("" = 기본 이름). 다른 사람에게 보이는 이름은 부지 속성 ShopName(필터 거친 글) |
|
||||
| Rainbow | bool | 무지개 이름 켜기 설정 |
|
||||
| RainbowOwned | bool | 무지개 이름 게임패스 보유 |
|
||||
| Design | string | 건물 디자인 id(Economy.DESIGNS) |
|
||||
| DesignsOwned | string | 유료 디자인 보유 목록 `"Candy,Hanok"` |
|
||||
| Double | bool | 2배 수익 |
|
||||
| Boost | number | 돈 부스트 팩 지급액 |
|
||||
| Tut | number | 튜토리얼 단계(0 끝, 1 조리대로, 2 서빙, 3 사기) |
|
||||
| Carry, Hand | number, string | 든 접시 수, 든 메뉴 `"Gimbap,Sundae"` |
|
||||
| Orders | string | 메뉴별 열린 주문 `"Tteokbokki=2,Gimbap=1"` |
|
||||
| Lang, LangSetting, MouseLook, Sfx, Dev | | 설정(예전과 같음) |
|
||||
|
||||
## 부지 모델 속성 (workspace.BunsikWorld.Plots.PlotN, 모두에게 보임)
|
||||
|
||||
| 속성 | 뜻 |
|
||||
|---|---|
|
||||
| OwnerId, OwnerName | 플레이어 가게 주인 |
|
||||
| Npc | 이웃 가게(NPC) 번호 |
|
||||
| Level | 가게 레벨(Economy.shopLevel) |
|
||||
| Stage | 건물 단계 |
|
||||
| Menus | 파는 메뉴 `"Tteokbokki,Gimbap"` (메뉴판) |
|
||||
| PriceMult | 판매 금액 배율(메뉴판 값) |
|
||||
| ShopName | 필터를 거친 가게 이름("" = 기본 이름 "{name}의 분식집") |
|
||||
| Rainbow | 무지개 이름(게임패스 + 켜짐) |
|
||||
| Design | 건물 디자인 |
|
||||
| ShieldUntil | 손님 쫓아내기 보호가 끝나는 서버 시각 |
|
||||
|
||||
## 요청 (Action kind, arg)
|
||||
|
||||
| kind | arg | 서버가 하는 일 |
|
||||
|---|---|---|
|
||||
| `cookStart`, `cook` | 메뉴 | 요리 창(예전과 같음) |
|
||||
| `upgrade` | 갈래 id | 다음 단계 구매 |
|
||||
| `buySeat` | 테이블 번호 또는 nil | 의자 1개(빈 쪽에 자동 배치) |
|
||||
| `buyTable` | nil | 테이블 + 의자 1개(빈 곳 자동 배치) |
|
||||
| `buyDecor` | 소품 id | 소품 1개(빈 곳 자동 배치) |
|
||||
| `buyOffer` | `"Seat"`/`"Table"`/갈래 id | 화면 아래 추천 막대의 [사기] |
|
||||
| `move` | `{kind="stove"/"table"/"decor", i, x, z, f, r}` | 옮기기(Floor.move로 검사). 의자는 `{kind="chair", i, x=쪽(1~4), z=테이블 번호(0=그대로)}` |
|
||||
| `hire`, `fire` | 역할 id | 알바 고용·해고 |
|
||||
| `rename` | 문자열(최대 20자) | 이름 바꾸기(TextService 필터) |
|
||||
| `rainbow` | bool | 무지개 이름 켜기/끄기. 없으면 게임패스 결제 창 |
|
||||
| `design` | 디자인 id | 디자인 바꾸기(실내 분식집부터). 유료인데 없으면 결제 창 |
|
||||
| `promote` | `{ad=bool}` | 홍보. ad=true면 보상형 광고(서버가 AdService로 띄움), 아니면 대기 시간 확인 후 바로 |
|
||||
| `kick` | 부지 번호 | 손님 쫓아내기. 횟수가 있으면 바로 쓰고, 없으면 결제 창(결제되면 그 부지에 씀) |
|
||||
| `rush` | nil | 손님 러시 결제 창 |
|
||||
| `visit`, `lang`, `mouseLook`, `sfx`, `pass`, `boost`, `dev_*` | | 예전과 같음 |
|
||||
|
||||
## 알림 키 (Notify)
|
||||
|
||||
예전 키(`purchased` 등)에 더해:
|
||||
- `upgraded {track, level}` 갈래 업그레이드, `newMenu {menu}`, `expanded`(실내), `floor2`(2층)
|
||||
- `seatAdded`, `tableAdded`, `decorAdded {kind}`, `noSpace`(놓을 곳 없음), `seatMax`, `tableMax`, `needStage`
|
||||
- `placeFail {why}`: why = bounds | overlap | reserved | floor | blocked | chair
|
||||
- `hired {role}`, `fired {role}`, `staffLocked`, `staffMax`, `strike`(시급 부족), `strikeOver`
|
||||
- `renamed`, `nameRejected`(필터 실패·빈 이름), `designSet {design}`, `designLocked`(실내 분식집부터)
|
||||
- `promoted {n}`, `promoteNone`(데려올 손님 없음), `promoteFull`(빈자리 없음), `promoteWait {sec}`, `adUnavailable`
|
||||
- `kicked {n, shop}`(내가 쫓아냄), `kickedBy {name}`(내 가게 손님이 쫓겨남), `shielded`(보호 중), `kickOwn`(내 가게는 안 됨)
|
||||
- `rushOn {min}`, `notEnough {need}`
|
||||
38
bunsik-tycoon/src/shared/Codec.luau
Normal file
38
bunsik-tycoon/src/shared/Codec.luau
Normal file
@@ -0,0 +1,38 @@
|
||||
--!strict
|
||||
-- 속성(Attribute)에 표·목록을 글자로 담는 작은 도구. 속성은 표를 담을 수 없어서 씁니다.
|
||||
-- encodeMap({Cook=1, Server=0}, {"Cook","Server"}) -> "Cook=1,Server=0"
|
||||
-- decodeMap("Cook=1,Server=0") -> {Cook=1, Server=0}
|
||||
|
||||
local Codec = {}
|
||||
|
||||
function Codec.encodeMap(map: { [string]: number }, order: { string }): string
|
||||
local parts = {}
|
||||
for _, k in order do
|
||||
table.insert(parts, `{k}={map[k] or 0}`)
|
||||
end
|
||||
return table.concat(parts, ",")
|
||||
end
|
||||
|
||||
function Codec.decodeMap(s: any): { [string]: number }
|
||||
local out = {}
|
||||
if typeof(s) ~= "string" then
|
||||
return out
|
||||
end
|
||||
for k, v in string.gmatch(s, "([%w_]+)=([%-%d%.]+)") do
|
||||
out[k] = tonumber(v) or 0
|
||||
end
|
||||
return out
|
||||
end
|
||||
|
||||
function Codec.decodeList(s: any): { string }
|
||||
local out = {}
|
||||
if typeof(s) ~= "string" then
|
||||
return out
|
||||
end
|
||||
for item in string.gmatch(s, "[^,]+") do
|
||||
table.insert(out, item)
|
||||
end
|
||||
return out
|
||||
end
|
||||
|
||||
return Codec
|
||||
@@ -1,22 +1,43 @@
|
||||
--!strict
|
||||
-- 분식집 경제 수치. ECONOMY.md 표와 같은 숫자여야 합니다.
|
||||
-- 숫자를 바꾸면 `lune run tools/sim.luau` 로 구매 시점을 다시 확인합니다.
|
||||
--
|
||||
-- 2026-10-14: 한 줄로 쭉 사던 업그레이드 20개를 갈래(트랙)별로 나눴습니다.
|
||||
-- 갈래: 건물(포장마차 → 실내 → 2층), 메뉴 해금, 판매 금액, 손님 오는 속도, 화구, 쟁반, 알바생 기능
|
||||
-- 자리(테이블·의자)는 꾸미기에서 사고 원하는 곳에 놓습니다. 손님이 앉는 자리 수 = 놓은 의자 수입니다.
|
||||
-- 알바생은 알바생 기능을 산 뒤 역할(요리·서빙·홍보)별로 돈 주고 고용하고, 1분마다 시급을 줍니다.
|
||||
|
||||
export type Effect = {
|
||||
seats: number?, -- 테이블 수
|
||||
spawn: number?, -- 손님 간격(초)
|
||||
cook: number?, -- 조리 시간(초)
|
||||
price: number?, -- 가격 배율
|
||||
helper: boolean?, -- 알바생(조리 자동)
|
||||
menu: string?, -- 해금할 메뉴
|
||||
carry: number?, -- 한 번에 드는 접시 수
|
||||
stage: number?, -- 가게 단계(2 = 실내 분식집)
|
||||
export type Level = {
|
||||
cost: number,
|
||||
stage: number, -- 이 단계(건물) 이상이어야 살 수 있음
|
||||
value: any, -- 갈래마다 뜻이 다름(메뉴 이름, 배율, 초, 접시 수, 단계)
|
||||
}
|
||||
|
||||
export type Purchase = {
|
||||
export type Track = {
|
||||
id: string,
|
||||
cost: number,
|
||||
effect: Effect,
|
||||
levels: { Level },
|
||||
}
|
||||
|
||||
export type Levels = { [string]: number }
|
||||
|
||||
export type Staff = { [string]: number } -- 역할별 고용 수(Cook, Server, Promoter)
|
||||
|
||||
export type Stats = {
|
||||
stage: number,
|
||||
menus: { string },
|
||||
price: number,
|
||||
spawn: number, -- 손님 간격(초). 홍보 알바·손님 러시 반영 전 값
|
||||
cook: number,
|
||||
carry: number,
|
||||
staffUnlocked: boolean,
|
||||
seats: number,
|
||||
}
|
||||
|
||||
export type Role = {
|
||||
id: string,
|
||||
hire: number, -- 고용비(한 번)
|
||||
wage: number, -- 시급(1분마다, 판매 금액 배율을 곱함)
|
||||
max: number,
|
||||
}
|
||||
|
||||
export type Menu = {
|
||||
@@ -24,40 +45,35 @@ export type Menu = {
|
||||
icon: string,
|
||||
}
|
||||
|
||||
export type Stats = {
|
||||
seats: number,
|
||||
spawn: number,
|
||||
cook: number,
|
||||
price: number,
|
||||
helper: boolean,
|
||||
menus: { string },
|
||||
carry: number,
|
||||
stage: number,
|
||||
}
|
||||
|
||||
local Economy = {}
|
||||
|
||||
Economy.WALK = 5 -- 조리대 -> 테이블 -> 조리대 왕복(초, 시뮬레이터 가정)
|
||||
Economy.EAT = 6 -- 식사 시간(초)
|
||||
Economy.WALK_IN = 2.5 -- 손님이 입구에서 자리까지 걷는 시간(초)
|
||||
Economy.COUNTER_MAX = 3 -- 알바생이 미리 만들어 두는 접시 최대 수
|
||||
Economy.WALK_IN = 2.5 -- 손님이 입구에서 자리까지 걷는 기본 시간(초). 실제 길 길이에 맞춰 자리마다 바뀝니다
|
||||
Economy.COUNTER_MAX = 3 -- 요리 알바가 미리 만들어 두는 접시 최대 수(요리 알바 1명당)
|
||||
Economy.BOOST_MINUTES = 10 -- 돈 부스트 팩: 현재 1분 매출 x 10분
|
||||
Economy.BOOST_MIN = 100 -- 돈 부스트 팩 최소 지급액
|
||||
Economy.GUEST_MULT = 2 -- 다른 플레이어가 손님으로 오면 주인은 접시 값의 2배를 받습니다
|
||||
Economy.GUEST_WAIT = 60 -- 손님으로 온 플레이어가 음식을 기다리는 최대 시간(초)
|
||||
Economy.GUEST_BONUS_COOLDOWN = 60 -- 손님으로 먹었을 때 시식 보너스는 1분에 한 번
|
||||
|
||||
Economy.START = {
|
||||
money = 0,
|
||||
seats = 1,
|
||||
spawn = 6,
|
||||
cook = 2.5,
|
||||
price = 1,
|
||||
helper = false,
|
||||
menus = { "Tteokbokki" },
|
||||
carry = 1,
|
||||
stage = 1,
|
||||
}
|
||||
Economy.WAGE_PERIOD = 60 -- 시급은 1분마다 줍니다(게임 속 1시간 = 1분)
|
||||
Economy.STRIKE_RETRY = 5 -- 시급이 모자라 쉬는 알바생은 5초마다 다시 확인
|
||||
Economy.SERVER_TRIP = 3 -- 서빙 알바가 카운터에서 손님 자리까지 가는 기본 시간(초, 자리마다 바뀜)
|
||||
Economy.PROMOTER_MULT = 0.75 -- 홍보 알바가 있으면 손님 간격 x0.75
|
||||
|
||||
Economy.RUSH_SECONDS = 600 -- 손님 러시(유료): 10분 동안
|
||||
Economy.RUSH_MULT = 0.5 -- 손님 간격 절반
|
||||
Economy.PROMOTE_MAX = 3 -- 홍보 한 번에 옆 가게에서 데려오는 손님 수(빈자리만큼)
|
||||
Economy.PROMOTE_COOLDOWN = 180 -- 광고 없이 하는 홍보 대기 시간(초)
|
||||
Economy.PROMOTE_AD_COOLDOWN = 45 -- 광고를 보고 하는 홍보 대기 시간(초)
|
||||
Economy.KICK_SHIELD = 180 -- 손님을 쫓겨난 가게는 3분 동안 다시 쫓겨나지 않음
|
||||
Economy.TRANSFER_WALK = 7 -- 옆 가게에서 우리 가게 자리까지 걸어오는 시간(초)
|
||||
|
||||
Economy.START_MONEY = 0
|
||||
Economy.START_SPAWN = 10 -- 처음 손님 간격(예전 6초에서 느리게)
|
||||
Economy.START_COOK = 2.5
|
||||
Economy.START_MENUS = { "Tteokbokki" }
|
||||
|
||||
Economy.MENUS = {
|
||||
Tteokbokki = { price = 15, icon = "🌶️" },
|
||||
@@ -70,89 +86,270 @@ Economy.MENUS = {
|
||||
-- 메뉴 표시 순서
|
||||
Economy.MENU_ORDER = { "Tteokbokki", "Gimbap", "Sundae", "Eomuk", "Twigim" }
|
||||
|
||||
-- 1~10: 첫 10분(1단계 포장마차). 11~20: 2단계 실내 분식집.
|
||||
Economy.PURCHASES = {
|
||||
{ id = "Table2", cost = 10, effect = { seats = 2 } },
|
||||
{ id = "UnlockGimbap", cost = 40, effect = { menu = "Gimbap" } },
|
||||
{ id = "Sign1", cost = 70, effect = { spawn = 5 } },
|
||||
{ id = "Stove1", cost = 90, effect = { cook = 1.5 } },
|
||||
{ id = "Table3", cost = 120, effect = { seats = 3 } },
|
||||
{ id = "UnlockSundae", cost = 160, effect = { menu = "Sundae" } },
|
||||
{ id = "Sauce1", cost = 240, effect = { price = 1.5 } },
|
||||
{ id = "Helper", cost = 360, effect = { helper = true } },
|
||||
{ id = "Table4", cost = 480, effect = { seats = 4, spawn = 4 } },
|
||||
{ id = "Expand", cost = 600, effect = { stage = 2 } },
|
||||
|
||||
{ id = "Tray1", cost = 700, effect = { carry = 2 } },
|
||||
{ id = "Table5", cost = 800, effect = { seats = 5 } },
|
||||
-- 업그레이드 갈래. 각 갈래는 앞 단계부터 차례로 삽니다.
|
||||
Economy.TRACKS = {
|
||||
{
|
||||
id = "UnlockEomuk",
|
||||
cost = 950,
|
||||
effect = { menu = "Eomuk" },
|
||||
id = "Stage", -- 건물: 1 포장마차 → 2 실내 분식집 → 3 2층
|
||||
levels = {
|
||||
{ cost = 450, stage = 1, value = 2 },
|
||||
{ cost = 5000, stage = 2, value = 3 },
|
||||
},
|
||||
},
|
||||
{ id = "Sign2", cost = 1150, effect = { spawn = 3 } },
|
||||
{ id = "Table6", cost = 1400, effect = { seats = 6 } },
|
||||
{ id = "Stove2", cost = 1700, effect = { cook = 1 } },
|
||||
{
|
||||
id = "UnlockTwigim",
|
||||
cost = 2000,
|
||||
effect = { menu = "Twigim" },
|
||||
id = "Menu", -- 새 메뉴 해금
|
||||
levels = {
|
||||
{ cost = 40, stage = 1, value = "Gimbap" },
|
||||
{ cost = 160, stage = 1, value = "Sundae" },
|
||||
{ cost = 950, stage = 2, value = "Eomuk" },
|
||||
{ cost = 2000, stage = 2, value = "Twigim" },
|
||||
},
|
||||
},
|
||||
{ id = "Sauce2", cost = 2500, effect = { price = 2 } },
|
||||
{ id = "Tray2", cost = 3000, effect = { carry = 3 } },
|
||||
{ id = "Table8", cost = 3600, effect = { seats = 8, spawn = 2.5 } },
|
||||
} :: { Purchase }
|
||||
{
|
||||
id = "Price", -- 판매 금액(양념 비법): 모든 메뉴 값 배율
|
||||
levels = {
|
||||
{ cost = 120, stage = 1, value = 1.25 },
|
||||
{ cost = 260, stage = 1, value = 1.5 },
|
||||
{ cost = 1100, stage = 2, value = 1.75 },
|
||||
{ cost = 2400, stage = 2, value = 2 },
|
||||
{ cost = 7000, stage = 3, value = 2.5 },
|
||||
{ cost = 12000, stage = 3, value = 3 },
|
||||
},
|
||||
},
|
||||
{
|
||||
id = "Speed", -- 손님 오는 속도(간판·전단지): 손님 간격(초)
|
||||
levels = {
|
||||
{ cost = 60, stage = 1, value = 8.5 },
|
||||
{ cost = 150, stage = 1, value = 7 },
|
||||
{ cost = 320, stage = 1, value = 6 },
|
||||
{ cost = 1000, stage = 2, value = 5 },
|
||||
{ cost = 2000, stage = 2, value = 4.2 },
|
||||
{ cost = 6500, stage = 3, value = 3.5 },
|
||||
{ cost = 11000, stage = 3, value = 3 },
|
||||
},
|
||||
},
|
||||
{
|
||||
id = "Stove", -- 화구: 요리 창에서 누르는 양(조리 수준)
|
||||
levels = {
|
||||
{ cost = 90, stage = 1, value = 1.8 },
|
||||
{ cost = 800, stage = 2, value = 1.4 },
|
||||
{ cost = 1800, stage = 2, value = 1 },
|
||||
},
|
||||
},
|
||||
{
|
||||
id = "Tray", -- 쟁반: 한 번에 드는 접시 수
|
||||
levels = {
|
||||
{ cost = 700, stage = 2, value = 2 },
|
||||
{ cost = 2600, stage = 2, value = 3 },
|
||||
},
|
||||
},
|
||||
{
|
||||
id = "Staff", -- 알바생 기능 해금(이걸 사야 알바생을 고용할 수 있음)
|
||||
levels = {
|
||||
{ cost = 250, stage = 1, value = true },
|
||||
},
|
||||
},
|
||||
} :: { Track }
|
||||
|
||||
Economy.MAX_SEATS = 8
|
||||
Economy.TRACK_ORDER = {} :: { string }
|
||||
local trackById: { [string]: Track } = {}
|
||||
for _, t in Economy.TRACKS do
|
||||
table.insert(Economy.TRACK_ORDER, t.id)
|
||||
trackById[t.id] = t
|
||||
end
|
||||
|
||||
-- 앞에서부터 `bought`개를 산 상태의 능력치
|
||||
function Economy.statsAt(bought: number): Stats
|
||||
local s = Economy.START
|
||||
function Economy.track(id: string): Track?
|
||||
return trackById[id]
|
||||
end
|
||||
|
||||
-- 알바생 역할. 시급은 판매 금액 배율만큼 오릅니다(가게가 클수록 시급도 높음).
|
||||
Economy.ROLES = {
|
||||
{ id = "Cook", hire = 200, wage = 12, max = 2 }, -- 요리: 카운터에 접시를 만들어 둠
|
||||
{ id = "Server", hire = 500, wage = 15, max = 2 }, -- 서빙: 카운터 접시를 손님 자리로 날라 줌
|
||||
{ id = "Promoter", hire = 400, wage = 10, max = 1 }, -- 홍보: 입구에서 전단지, 손님 간격 x0.75
|
||||
} :: { Role }
|
||||
|
||||
local roleById: { [string]: Role } = {}
|
||||
for _, r in Economy.ROLES do
|
||||
roleById[r.id] = r
|
||||
end
|
||||
|
||||
function Economy.role(id: string): Role?
|
||||
return roleById[id]
|
||||
end
|
||||
|
||||
-- 자리(손님 의자). 테이블 하나에 의자 4개까지. 건물 단계별로 놓을 수 있는 수가 다릅니다.
|
||||
Economy.CHAIRS_PER_TABLE = 4
|
||||
Economy.SEAT_CAP = { 6, 14, 24 } -- 단계별 최대 의자 수
|
||||
Economy.TABLE_CAP = { 3, 6, 12 } -- 단계별 최대 테이블 수
|
||||
|
||||
-- s번째 자리(의자)를 사는 값. 처음 자리는 공짜(처음부터 테이블 1 + 의자 1).
|
||||
function Economy.seatCost(s: number): number
|
||||
if s <= 1 then
|
||||
return 0
|
||||
end
|
||||
local raw = 10 * (s - 1) ^ 2.1
|
||||
return math.floor(raw / 5 + 0.5) * 5
|
||||
end
|
||||
|
||||
-- 테이블(의자 1개 포함)은 자리 값에 테이블 값을 더합니다.
|
||||
function Economy.tableCost(tables: number, seats: number): number
|
||||
return Economy.seatCost(seats + 1) + 15 * tables * tables
|
||||
end
|
||||
|
||||
-- 꾸미기 소품(손님 수와 상관없는 장식). 크기는 Floor.FOOTPRINT
|
||||
Economy.DECOR = {
|
||||
{ id = "Plant", cost = 50 },
|
||||
{ id = "Rug", cost = 80 },
|
||||
{ id = "Balloons", cost = 120 },
|
||||
{ id = "Lamp", cost = 150 },
|
||||
{ id = "Teddy", cost = 250 },
|
||||
{ id = "Fridge", cost = 400 },
|
||||
} :: { { id: string, cost: number } }
|
||||
|
||||
Economy.DECOR_MAX = 20
|
||||
|
||||
function Economy.decor(id: string): { id: string, cost: number }?
|
||||
for _, d in Economy.DECOR do
|
||||
if d.id == id then
|
||||
return d
|
||||
end
|
||||
end
|
||||
return nil
|
||||
end
|
||||
|
||||
-- 가게 건물 디자인(실내 분식집 이상에서 바꿀 수 있음). pass가 있으면 게임패스(Products 키)로 삽니다.
|
||||
Economy.DESIGNS = {
|
||||
{ id = "Basic" },
|
||||
{ id = "Mint" },
|
||||
{ id = "Brick" },
|
||||
{ id = "Candy", pass = "CANDY_DESIGN_PASS" },
|
||||
{ id = "Hanok", pass = "HANOK_DESIGN_PASS" },
|
||||
} :: { { id: string, pass: string? } }
|
||||
|
||||
function Economy.design(id: string): { id: string, pass: string? }?
|
||||
for _, d in Economy.DESIGNS do
|
||||
if d.id == id then
|
||||
return d
|
||||
end
|
||||
end
|
||||
return nil
|
||||
end
|
||||
|
||||
Economy.NAME_MAX = 20 -- 가게 이름 최대 글자 수
|
||||
|
||||
function Economy.level(levels: Levels, id: string): number
|
||||
return levels[id] or 0
|
||||
end
|
||||
|
||||
function Economy.emptyLevels(): Levels
|
||||
local out = {}
|
||||
for _, id in Economy.TRACK_ORDER do
|
||||
out[id] = 0
|
||||
end
|
||||
return out
|
||||
end
|
||||
|
||||
-- 저장된 값을 정리합니다(없는 갈래, 범위 밖 숫자).
|
||||
function Economy.cleanLevels(raw: any): Levels
|
||||
local out = Economy.emptyLevels()
|
||||
if typeof(raw) == "table" then
|
||||
for _, t in Economy.TRACKS do
|
||||
local v = raw[t.id]
|
||||
if typeof(v) == "number" then
|
||||
out[t.id] = math.clamp(math.floor(v), 0, #t.levels)
|
||||
end
|
||||
end
|
||||
end
|
||||
return out
|
||||
end
|
||||
|
||||
-- 갈래 레벨과 자리 수로 능력치를 계산합니다.
|
||||
function Economy.stats(levels: Levels, seats: number): Stats
|
||||
local stats: Stats = {
|
||||
seats = s.seats,
|
||||
spawn = s.spawn,
|
||||
cook = s.cook,
|
||||
price = s.price,
|
||||
helper = s.helper,
|
||||
menus = table.clone(s.menus),
|
||||
carry = s.carry,
|
||||
stage = s.stage,
|
||||
stage = 1,
|
||||
menus = table.clone(Economy.START_MENUS),
|
||||
price = 1,
|
||||
spawn = Economy.START_SPAWN,
|
||||
cook = Economy.START_COOK,
|
||||
carry = 1,
|
||||
staffUnlocked = false,
|
||||
seats = math.max(1, seats),
|
||||
}
|
||||
for i = 1, math.min(bought, #Economy.PURCHASES) do
|
||||
local e = Economy.PURCHASES[i].effect
|
||||
if e.seats then
|
||||
stats.seats = e.seats
|
||||
end
|
||||
if e.spawn then
|
||||
stats.spawn = e.spawn
|
||||
end
|
||||
if e.cook then
|
||||
stats.cook = e.cook
|
||||
end
|
||||
if e.price then
|
||||
stats.price = e.price
|
||||
end
|
||||
if e.helper then
|
||||
stats.helper = true
|
||||
end
|
||||
if e.menu then
|
||||
table.insert(stats.menus, e.menu)
|
||||
end
|
||||
if e.carry then
|
||||
stats.carry = e.carry
|
||||
end
|
||||
if e.stage then
|
||||
stats.stage = e.stage
|
||||
for _, t in Economy.TRACKS do
|
||||
local n = math.min(levels[t.id] or 0, #t.levels)
|
||||
for i = 1, n do
|
||||
local v = t.levels[i].value
|
||||
if t.id == "Stage" then
|
||||
stats.stage = v
|
||||
elseif t.id == "Menu" then
|
||||
table.insert(stats.menus, v)
|
||||
elseif t.id == "Price" then
|
||||
stats.price = v
|
||||
elseif t.id == "Speed" then
|
||||
stats.spawn = v
|
||||
elseif t.id == "Stove" then
|
||||
stats.cook = v
|
||||
elseif t.id == "Tray" then
|
||||
stats.carry = v
|
||||
elseif t.id == "Staff" then
|
||||
stats.staffUnlocked = true
|
||||
end
|
||||
end
|
||||
end
|
||||
return stats
|
||||
end
|
||||
|
||||
-- 갈래의 다음 단계(없으면 nil)
|
||||
function Economy.nextLevel(levels: Levels, id: string): Level?
|
||||
local t = trackById[id]
|
||||
if not t then
|
||||
return nil
|
||||
end
|
||||
return t.levels[(levels[id] or 0) + 1]
|
||||
end
|
||||
|
||||
function Economy.seatCap(stage: number): number
|
||||
return Economy.SEAT_CAP[math.clamp(stage, 1, #Economy.SEAT_CAP)]
|
||||
end
|
||||
|
||||
function Economy.tableCap(stage: number): number
|
||||
return Economy.TABLE_CAP[math.clamp(stage, 1, #Economy.TABLE_CAP)]
|
||||
end
|
||||
|
||||
-- 한 접시 값(정수). moneyMult는 2배 수익 게임패스(1 또는 2)
|
||||
function Economy.dishPrice(menu: string, stats: Stats, moneyMult: number): number
|
||||
return math.floor(Economy.MENUS[menu].price * stats.price) * moneyMult
|
||||
end
|
||||
|
||||
-- 역할별 시급(1분마다)
|
||||
function Economy.wage(roleId: string, stats: Stats): number
|
||||
local r = roleById[roleId]
|
||||
if not r then
|
||||
return 0
|
||||
end
|
||||
return math.floor(r.wage * stats.price + 0.5)
|
||||
end
|
||||
|
||||
function Economy.totalWage(staff: Staff, stats: Stats): number
|
||||
local total = 0
|
||||
for _, r in Economy.ROLES do
|
||||
total += (staff[r.id] or 0) * Economy.wage(r.id, stats)
|
||||
end
|
||||
return total
|
||||
end
|
||||
|
||||
-- 손님 간격(초): 홍보 알바, 손님 러시 반영
|
||||
function Economy.spawnInterval(stats: Stats, promoters: number, rush: boolean): number
|
||||
local s = stats.spawn
|
||||
if promoters > 0 then
|
||||
s *= Economy.PROMOTER_MULT
|
||||
end
|
||||
if rush then
|
||||
s *= Economy.RUSH_MULT
|
||||
end
|
||||
return s
|
||||
end
|
||||
|
||||
-- 현재 능력치로 1분에 버는 돈(대략). 돈 부스트 팩 지급액 계산용
|
||||
function Economy.incomePerMinute(stats: Stats): number
|
||||
local total = 0
|
||||
@@ -170,4 +367,132 @@ function Economy.boostAmount(stats: Stats): number
|
||||
return math.max(Economy.BOOST_MIN, Economy.incomePerMinute(stats) * Economy.BOOST_MINUTES)
|
||||
end
|
||||
|
||||
-- 이름판에 붙는 가게 레벨: 산 업그레이드 단계 수 + 늘린 자리 수
|
||||
function Economy.shopLevel(levels: Levels, seats: number): number
|
||||
local n = math.max(0, seats - 1)
|
||||
for _, id in Economy.TRACK_ORDER do
|
||||
n += levels[id] or 0
|
||||
end
|
||||
return n
|
||||
end
|
||||
|
||||
export type Offer = {
|
||||
kind: string, -- "track" | "seat" | "table"
|
||||
id: string, -- 갈래 id 또는 "Seat"/"Table"
|
||||
cost: number,
|
||||
}
|
||||
|
||||
-- 지금 살 수 있는 다음 단계들(건물 단계 조건을 채운 것). 화면 아래 "다음 업그레이드" 추천과 봇이 씁니다.
|
||||
-- tables: 놓은 테이블 수, seats: 놓은 의자 수
|
||||
function Economy.offers(levels: Levels, tables: number, seats: number): { Offer }
|
||||
local stats = Economy.stats(levels, seats)
|
||||
local out: { Offer } = {}
|
||||
for _, id in Economy.TRACK_ORDER do
|
||||
local nl = Economy.nextLevel(levels, id)
|
||||
if nl and nl.stage <= stats.stage then
|
||||
table.insert(out, { kind = "track", id = id, cost = nl.cost })
|
||||
end
|
||||
end
|
||||
if seats < Economy.seatCap(stats.stage) then
|
||||
if seats < tables * Economy.CHAIRS_PER_TABLE then
|
||||
table.insert(out, { kind = "seat", id = "Seat", cost = Economy.seatCost(seats + 1) })
|
||||
end
|
||||
if tables < Economy.tableCap(stats.stage) then
|
||||
table.insert(out, { kind = "table", id = "Table", cost = Economy.tableCost(tables, seats) })
|
||||
end
|
||||
end
|
||||
table.sort(out, function(a, b)
|
||||
if a.cost ~= b.cost then
|
||||
return a.cost < b.cost
|
||||
end
|
||||
return a.id < b.id
|
||||
end)
|
||||
return out
|
||||
end
|
||||
|
||||
-- 예전 세이브(한 줄 업그레이드 Bought개)를 갈래 레벨로 옮깁니다.
|
||||
-- 돌려주는 값: 레벨, 자리 수, 테이블 수, 요리 알바 수
|
||||
function Economy.migrate(bought: number): (Levels, number, number, number)
|
||||
local OLD = {
|
||||
"Table2",
|
||||
"UnlockGimbap",
|
||||
"Sign1",
|
||||
"Stove1",
|
||||
"Table3",
|
||||
"UnlockSundae",
|
||||
"Sauce1",
|
||||
"Helper",
|
||||
"Table4",
|
||||
"Expand",
|
||||
"Tray1",
|
||||
"Table5",
|
||||
"UnlockEomuk",
|
||||
"Sign2",
|
||||
"Table6",
|
||||
"Stove2",
|
||||
"UnlockTwigim",
|
||||
"Sauce2",
|
||||
"Tray2",
|
||||
"Table8",
|
||||
}
|
||||
local levels = Economy.emptyLevels()
|
||||
local seats = 1
|
||||
local cooks = 0
|
||||
local function up(id: string, n: number)
|
||||
levels[id] = math.max(levels[id], n)
|
||||
end
|
||||
for i = 1, math.clamp(bought, 0, #OLD) do
|
||||
local id = OLD[i]
|
||||
if id == "Table2" then
|
||||
seats = 2
|
||||
elseif id == "Table3" then
|
||||
seats = 3
|
||||
elseif id == "Table4" then
|
||||
seats = 4
|
||||
up("Speed", 3)
|
||||
elseif id == "Table5" then
|
||||
seats = 5
|
||||
elseif id == "Table6" then
|
||||
seats = 6
|
||||
elseif id == "Table8" then
|
||||
seats = 8
|
||||
up("Speed", 5)
|
||||
elseif id == "UnlockGimbap" then
|
||||
up("Menu", 1)
|
||||
elseif id == "UnlockSundae" then
|
||||
up("Menu", 2)
|
||||
elseif id == "UnlockEomuk" then
|
||||
up("Menu", 3)
|
||||
elseif id == "UnlockTwigim" then
|
||||
up("Menu", 4)
|
||||
elseif id == "Sign1" then
|
||||
up("Speed", 2)
|
||||
elseif id == "Sign2" then
|
||||
up("Speed", 4)
|
||||
elseif id == "Stove1" then
|
||||
up("Stove", 1)
|
||||
elseif id == "Stove2" then
|
||||
up("Stove", 3)
|
||||
elseif id == "Sauce1" then
|
||||
up("Price", 2)
|
||||
elseif id == "Sauce2" then
|
||||
up("Price", 4)
|
||||
elseif id == "Helper" then
|
||||
up("Staff", 1)
|
||||
cooks = 1
|
||||
elseif id == "Expand" then
|
||||
up("Stage", 1)
|
||||
elseif id == "Tray1" then
|
||||
up("Tray", 1)
|
||||
elseif id == "Tray2" then
|
||||
up("Tray", 2)
|
||||
end
|
||||
end
|
||||
-- 예전 테이블은 1인석이었으므로 자리 수만큼 테이블을 둡니다(단계별 최대 수 안에서).
|
||||
local stage = Economy.stats(levels, seats).stage
|
||||
local tables = math.min(seats, Economy.tableCap(stage))
|
||||
seats = math.min(seats, tables * Economy.CHAIRS_PER_TABLE)
|
||||
return levels, seats, tables, cooks
|
||||
end
|
||||
|
||||
return Economy
|
||||
|
||||
831
bunsik-tycoon/src/shared/Floor.luau
Normal file
831
bunsik-tycoon/src/shared/Floor.luau
Normal file
@@ -0,0 +1,831 @@
|
||||
--!strict
|
||||
-- 가게 안 배치(테이블·의자·조리대·소품)와 손님 길 찾기. 로블록스 API 없이 lune에서도 돌아갑니다.
|
||||
-- 좌표는 부지 기준 상대 좌표(stud)입니다. 부지 원점은 바닥 가운데, +Z가 길(입구) 쪽.
|
||||
-- 배치할 수 있는 곳은 건물 안쪽과 같은 넓이(포장마차 단계에서도 같음), 2층은 2층 건물(3단계)부터.
|
||||
--
|
||||
-- 저장 모양(Layout):
|
||||
-- stove = { x, z, r } 조리대(포장마차 수레 + 카운터). r은 90도 단위 회전(0~3), 앞(+Z)으로 손님을 봄
|
||||
-- tables = { { x, z, f } } f = 층(1 또는 2)
|
||||
-- chairs = { { t, s } } t = 테이블 번호, s = 테이블의 어느 쪽(1 앞 +Z, 2 오른쪽 +X, 3 뒤 -Z, 4 왼쪽 -X)
|
||||
-- decor = { { k, x, z, f, r } } k = 소품 종류(Economy.DECOR)
|
||||
-- 의자는 테이블에 붙어 있어서 테이블을 옮기면 같이 옮겨집니다. 손님 자리 번호 = chairs 순서.
|
||||
|
||||
export type Pos = { x: number, z: number, f: number }
|
||||
export type Stove = { x: number, z: number, r: number }
|
||||
export type Table = { x: number, z: number, f: number }
|
||||
export type Chair = { t: number, s: number }
|
||||
export type Decor = { k: string, x: number, z: number, f: number, r: number }
|
||||
|
||||
export type Layout = {
|
||||
stove: Stove,
|
||||
tables: { Table },
|
||||
chairs: { Chair },
|
||||
decor: { Decor },
|
||||
}
|
||||
|
||||
export type Rect = { x0: number, z0: number, x1: number, z1: number, f: number }
|
||||
|
||||
local Floor = {}
|
||||
|
||||
-- 배치할 수 있는 넓이(건물 안쪽 벽에서 1 stud 띄움)
|
||||
Floor.X0 = -33
|
||||
Floor.X1 = 33
|
||||
Floor.Z0 = -37
|
||||
Floor.Z1 = 19
|
||||
Floor.FLOOR2_Y = 15 -- 2층 바닥 높이(1층 바닥 기준)
|
||||
Floor.CELL = 1
|
||||
|
||||
Floor.DOOR = { x = 0, z = 19.5, f = 1 } -- 손님이 들어오는 문 안쪽
|
||||
Floor.ENTRANCE = { x = 0, z = 32, f = 1 } -- 부지 입구(길 쪽)
|
||||
-- 2층 계단: 왼쪽 벽을 따라 앞(아래)에서 뒤(위)로 올라갑니다.
|
||||
Floor.STAIR_X = -30.5
|
||||
Floor.STAIR_BOTTOM = { x = -30.5, z = 9, f = 1 }
|
||||
Floor.STAIR_TOP = { x = -30.5, z = -23, f = 2 }
|
||||
Floor.STAIR_HALF_W = 2.5
|
||||
|
||||
Floor.TABLE_SIZE = 5
|
||||
Floor.CHAIR_SIZE = 2
|
||||
Floor.CHAIR_OFFSET = 3.5 -- 테이블 가운데에서 의자 가운데까지
|
||||
|
||||
-- 소품 크기(가로 x, 세로 z, 회전 0 기준). walk = 밟고 지나갈 수 있음(러그)
|
||||
Floor.FOOTPRINT = {
|
||||
Stove = { w = 22, d = 10.5, walk = false },
|
||||
Plant = { w = 2, d = 2, walk = false },
|
||||
Rug = { w = 8, d = 6, walk = true },
|
||||
Balloons = { w = 2, d = 2, walk = false },
|
||||
Lamp = { w = 2, d = 2, walk = false },
|
||||
Teddy = { w = 3, d = 3, walk = false },
|
||||
Fridge = { w = 4, d = 2, walk = false },
|
||||
} :: { [string]: { w: number, d: number, walk: boolean } }
|
||||
|
||||
-- 조리대 안의 위치(조리대 기준, 회전 0). 플레이어는 앞(+Z)에 서서 요리합니다.
|
||||
Floor.STOVE_COOK = { x = -3, z = 0 } -- 화구
|
||||
Floor.STOVE_COUNTER = { x = 5.5, z = 0 } -- 카운터(알바생 접시)
|
||||
Floor.STOVE_FRONT = { x = 0, z = 4.5 } -- 플레이어가 서는 곳
|
||||
Floor.STOVE_BACK = { x = -3, z = -4 } -- 요리 알바가 서는 곳
|
||||
|
||||
local SIDES = {
|
||||
{ x = 0, z = 1 },
|
||||
{ x = 1, z = 0 },
|
||||
{ x = 0, z = -1 },
|
||||
{ x = -1, z = 0 },
|
||||
}
|
||||
Floor.SIDES = SIDES
|
||||
|
||||
function Floor.default(): Layout
|
||||
return {
|
||||
stove = { x = 0, z = -26, r = 0 },
|
||||
tables = { { x = -9, z = -10, f = 1 } },
|
||||
chairs = { { t = 1, s = 1 } },
|
||||
decor = {},
|
||||
}
|
||||
end
|
||||
|
||||
-- 회전(0~3, 90도 단위)한 상대 좌표. r=1이면 +Z가 +X 쪽을 봅니다.
|
||||
function Floor.rotate(x: number, z: number, r: number): (number, number)
|
||||
r = r % 4
|
||||
if r == 0 then
|
||||
return x, z
|
||||
elseif r == 1 then
|
||||
return z, -x
|
||||
elseif r == 2 then
|
||||
return -x, -z
|
||||
end
|
||||
return -z, x
|
||||
end
|
||||
|
||||
-- 조리대 기준 상대 위치를 부지 좌표로
|
||||
function Floor.stovePoint(stove: Stove, p: { x: number, z: number }): (number, number)
|
||||
local dx, dz = Floor.rotate(p.x, p.z, stove.r)
|
||||
return stove.x + dx, stove.z + dz
|
||||
end
|
||||
|
||||
function Floor.chairPos(layout: Layout, i: number): Pos?
|
||||
local c = layout.chairs[i]
|
||||
local t = c and layout.tables[c.t]
|
||||
if not t then
|
||||
return nil
|
||||
end
|
||||
local d = SIDES[c.s]
|
||||
if not d then
|
||||
return nil
|
||||
end
|
||||
return { x = t.x + d.x * Floor.CHAIR_OFFSET, z = t.z + d.z * Floor.CHAIR_OFFSET, f = t.f }
|
||||
end
|
||||
|
||||
local function rectAt(x: number, z: number, w: number, d: number, r: number, f: number): Rect
|
||||
if r % 2 == 1 then
|
||||
w, d = d, w
|
||||
end
|
||||
return { x0 = x - w / 2, z0 = z - d / 2, x1 = x + w / 2, z1 = z + d / 2, f = f }
|
||||
end
|
||||
|
||||
local function overlap(a: Rect, b: Rect): boolean
|
||||
return a.f == b.f and a.x0 < b.x1 - 1e-6 and b.x0 < a.x1 - 1e-6 and a.z0 < b.z1 - 1e-6 and b.z0 < a.z1 - 1e-6
|
||||
end
|
||||
|
||||
-- 아무것도 놓을 수 없는 곳: 문 앞, 계단(2층 건물일 때)
|
||||
function Floor.reserved(stage: number): { Rect }
|
||||
local out: { Rect } = {
|
||||
{ x0 = -5, z0 = 14, x1 = 5, z1 = 20, f = 1 },
|
||||
}
|
||||
if stage >= 3 then
|
||||
local w = Floor.STAIR_HALF_W + 0.5
|
||||
-- 1층: 계단과 아래 계단참, 2층: 계단 구멍과 위 계단참
|
||||
table.insert(out, { x0 = Floor.STAIR_X - w, z0 = -24, x1 = Floor.STAIR_X + w, z1 = 13, f = 1 })
|
||||
table.insert(out, { x0 = Floor.STAIR_X - w, z0 = -27, x1 = Floor.STAIR_X + w, z1 = 13, f = 2 })
|
||||
end
|
||||
return out
|
||||
end
|
||||
|
||||
export type Piece = { kind: string, index: number, rect: Rect, walk: boolean }
|
||||
|
||||
-- 배치된 모든 물건의 바닥 차지 영역
|
||||
function Floor.pieces(layout: Layout): { Piece }
|
||||
local out: { Piece } = {}
|
||||
local s = layout.stove
|
||||
local fp = Floor.FOOTPRINT.Stove
|
||||
-- 조리대 영역: 수레와 뒤쪽(알바생·진열대) + 천막 앞 기둥 2개. 플레이어가 서는 앞쪽(천막 아래)은 비워 둡니다.
|
||||
local cx, cz = Floor.stovePoint(s, { x = 0, z = -2.75 })
|
||||
table.insert(out, { kind = "stove", index = 1, rect = rectAt(cx, cz, fp.w, fp.d, s.r, 1), walk = false })
|
||||
for _, px in { -10, 10 } do
|
||||
local qx, qz = Floor.stovePoint(s, { x = px, z = 6 })
|
||||
table.insert(out, { kind = "stove", index = 1, rect = rectAt(qx, qz, 1, 1, 0, 1), walk = false })
|
||||
end
|
||||
for i, t in layout.tables do
|
||||
table.insert(out, {
|
||||
kind = "table",
|
||||
index = i,
|
||||
rect = rectAt(t.x, t.z, Floor.TABLE_SIZE, Floor.TABLE_SIZE, 0, t.f),
|
||||
walk = false,
|
||||
})
|
||||
end
|
||||
for i in layout.chairs do
|
||||
local p = Floor.chairPos(layout, i)
|
||||
if p then
|
||||
table.insert(out, {
|
||||
kind = "chair",
|
||||
index = i,
|
||||
rect = rectAt(p.x, p.z, Floor.CHAIR_SIZE, Floor.CHAIR_SIZE, 0, p.f),
|
||||
walk = false,
|
||||
})
|
||||
end
|
||||
end
|
||||
for i, d in layout.decor do
|
||||
local f = Floor.FOOTPRINT[d.k]
|
||||
if f then
|
||||
table.insert(out, { kind = "decor", index = i, rect = rectAt(d.x, d.z, f.w, f.d, d.r, d.f), walk = f.walk })
|
||||
end
|
||||
end
|
||||
return out
|
||||
end
|
||||
|
||||
-- 격자(1 stud 칸). 막힌 칸 = true
|
||||
type Grid = { [number]: boolean }
|
||||
|
||||
local NX = math.floor((Floor.X1 - Floor.X0) / Floor.CELL + 0.5) + 2 -- 벽 쪽 1칸씩 여유
|
||||
local NZ = math.floor((Floor.Z1 - Floor.Z0) / Floor.CELL + 0.5) + 2
|
||||
local GX0 = Floor.X0 - Floor.CELL
|
||||
local GZ0 = Floor.Z0 - Floor.CELL
|
||||
|
||||
local function cellOf(x: number, z: number): (number, number)
|
||||
return math.floor((x - GX0) / Floor.CELL), math.floor((z - GZ0) / Floor.CELL)
|
||||
end
|
||||
|
||||
local function cellCenter(i: number, j: number): (number, number)
|
||||
return GX0 + (i + 0.5) * Floor.CELL, GZ0 + (j + 0.5) * Floor.CELL
|
||||
end
|
||||
|
||||
local function key(i: number, j: number): number
|
||||
return j * NX + i
|
||||
end
|
||||
|
||||
local function inGrid(i: number, j: number): boolean
|
||||
return i >= 0 and j >= 0 and i < NX and j < NZ
|
||||
end
|
||||
|
||||
local function blockRect(g: Grid, r: Rect, pad: number)
|
||||
local i0, j0 = cellOf(r.x0 - pad + 1e-6, r.z0 - pad + 1e-6)
|
||||
local i1, j1 = cellOf(r.x1 + pad - 1e-6, r.z1 + pad - 1e-6)
|
||||
for i = i0, i1 do
|
||||
for j = j0, j1 do
|
||||
if inGrid(i, j) then
|
||||
g[key(i, j)] = true
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
-- 층별 막힌 칸. 계단 구멍(2층)도 막습니다. 계단 자체(1층)는 걸어서 지나갈 수 없게 막습니다.
|
||||
local function buildGrid(layout: Layout, stage: number, f: number): Grid
|
||||
local g: Grid = {}
|
||||
for _, p in Floor.pieces(layout) do
|
||||
if p.rect.f == f and not p.walk then
|
||||
blockRect(g, p.rect, 0)
|
||||
end
|
||||
end
|
||||
if stage >= 3 then
|
||||
local w = Floor.STAIR_HALF_W
|
||||
if f == 1 then
|
||||
blockRect(g, { x0 = Floor.STAIR_X - w, z0 = -24, x1 = Floor.STAIR_X + w, z1 = 8, f = 1 }, 0)
|
||||
else
|
||||
blockRect(g, { x0 = Floor.STAIR_X - w, z0 = -22, x1 = Floor.STAIR_X + w, z1 = 13, f = 2 }, 0)
|
||||
end
|
||||
end
|
||||
return g
|
||||
end
|
||||
|
||||
-- start 칸에서 걸어서 닿는 칸들(4방향)
|
||||
local function flood(g: Grid, si: number, sj: number): { [number]: boolean }
|
||||
local seen: { [number]: boolean } = {}
|
||||
if not inGrid(si, sj) or g[key(si, sj)] then
|
||||
return seen
|
||||
end
|
||||
local qi, qj = { si }, { sj }
|
||||
seen[key(si, sj)] = true
|
||||
local h = 1
|
||||
while h <= #qi do
|
||||
local i, j = qi[h], qj[h]
|
||||
h += 1
|
||||
for _, d in SIDES do
|
||||
local ni, nj = i + d.x, j + d.z
|
||||
local k = key(ni, nj)
|
||||
if inGrid(ni, nj) and not g[k] and not seen[k] then
|
||||
seen[k] = true
|
||||
table.insert(qi, ni)
|
||||
table.insert(qj, nj)
|
||||
end
|
||||
end
|
||||
end
|
||||
return seen
|
||||
end
|
||||
|
||||
-- 사각형 바로 둘레 칸 중 닿는 칸이 있는지
|
||||
local function touches(seen: { [number]: boolean }, r: Rect): boolean
|
||||
local i0, j0 = cellOf(r.x0 - 0.5, r.z0 - 0.5)
|
||||
local i1, j1 = cellOf(r.x1 + 0.5 - 1e-6, r.z1 + 0.5 - 1e-6)
|
||||
for i = i0, i1 do
|
||||
for j = j0, j1 do
|
||||
if seen[key(i, j)] then
|
||||
return true
|
||||
end
|
||||
end
|
||||
end
|
||||
return false
|
||||
end
|
||||
|
||||
local function inBounds(r: Rect): boolean
|
||||
return r.x0 >= Floor.X0 - 1e-6 and r.x1 <= Floor.X1 + 1e-6 and r.z0 >= Floor.Z0 - 1e-6 and r.z1 <= Floor.Z1 + 1e-6
|
||||
end
|
||||
|
||||
-- 배치 전체를 검사합니다. 문제가 없으면 nil, 있으면 이유를 돌려줍니다.
|
||||
-- "bounds"(밖), "overlap"(겹침), "reserved"(문·계단), "floor"(2층 없음), "blocked"(길이 막힘), "chair"(잘못된 의자)
|
||||
function Floor.validate(layout: Layout, stage: number): string?
|
||||
local pieces = Floor.pieces(layout)
|
||||
if #pieces ~= 3 + #layout.tables + #layout.chairs + #layout.decor then
|
||||
return "chair"
|
||||
end
|
||||
local reserved = Floor.reserved(stage)
|
||||
for _, p in pieces do
|
||||
if p.rect.f ~= 1 and (p.rect.f ~= 2 or stage < 3) then
|
||||
return "floor"
|
||||
end
|
||||
if not inBounds(p.rect) then
|
||||
return "bounds"
|
||||
end
|
||||
for _, r in reserved do
|
||||
if overlap(p.rect, r) then
|
||||
return "reserved"
|
||||
end
|
||||
end
|
||||
end
|
||||
if layout.stove.r % 1 ~= 0 then
|
||||
return "bounds"
|
||||
end
|
||||
-- 같은 테이블의 같은 쪽에 의자 둘 금지
|
||||
local used: { [string]: boolean } = {}
|
||||
for _, c in layout.chairs do
|
||||
local k = `{c.t}:{c.s}`
|
||||
if used[k] then
|
||||
return "chair"
|
||||
end
|
||||
used[k] = true
|
||||
end
|
||||
for a = 1, #pieces do
|
||||
local pa = pieces[a]
|
||||
if not pa.walk then
|
||||
for b = a + 1, #pieces do
|
||||
local pb = pieces[b]
|
||||
if not pb.walk then
|
||||
-- 의자는 자기 테이블과 붙어 있어도 됩니다(실제로 겹치지 않음).
|
||||
if overlap(pa.rect, pb.rect) then
|
||||
return "overlap"
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
-- 길: 문에서 조리대 앞과 1층 의자, 2층은 계단 위에서 2층 의자까지 닿아야 합니다.
|
||||
local g1 = buildGrid(layout, stage, 1)
|
||||
local di, dj = cellOf(Floor.DOOR.x, Floor.DOOR.z - 0.6)
|
||||
local seen1 = flood(g1, di, dj)
|
||||
local fx, fz = Floor.stovePoint(layout.stove, Floor.STOVE_FRONT)
|
||||
local si, sj = cellOf(fx, fz)
|
||||
if not seen1[key(si, sj)] then
|
||||
return "blocked"
|
||||
end
|
||||
local seen2: { [number]: boolean }? = nil
|
||||
if stage >= 3 then
|
||||
local bi, bj = cellOf(Floor.STAIR_BOTTOM.x, Floor.STAIR_BOTTOM.z + 1.5)
|
||||
if not seen1[key(bi, bj)] then
|
||||
return "blocked"
|
||||
end
|
||||
local g2 = buildGrid(layout, stage, 2)
|
||||
local ti, tj = cellOf(Floor.STAIR_TOP.x, Floor.STAIR_TOP.z - 1.5)
|
||||
seen2 = flood(g2, ti, tj)
|
||||
end
|
||||
for _, p in pieces do
|
||||
if p.kind == "chair" then
|
||||
local seen = if p.rect.f == 1 then seen1 else seen2
|
||||
if not seen or not touches(seen, p.rect) then
|
||||
return "blocked"
|
||||
end
|
||||
end
|
||||
end
|
||||
return nil
|
||||
end
|
||||
|
||||
function Floor.clone(layout: Layout): Layout
|
||||
local out: Layout = {
|
||||
stove = table.clone(layout.stove),
|
||||
tables = {},
|
||||
chairs = {},
|
||||
decor = {},
|
||||
}
|
||||
for i, t in layout.tables do
|
||||
out.tables[i] = table.clone(t)
|
||||
end
|
||||
for i, c in layout.chairs do
|
||||
out.chairs[i] = table.clone(c)
|
||||
end
|
||||
for i, d in layout.decor do
|
||||
out.decor[i] = table.clone(d)
|
||||
end
|
||||
return out
|
||||
end
|
||||
|
||||
local function num(v: any, default: number): number
|
||||
return if typeof(v) == "number" and v == v and v ~= math.huge and v ~= -math.huge then v else default
|
||||
end
|
||||
|
||||
-- 저장된 값을 안전한 모양으로 고칩니다(빠진 값·이상한 값). 검사(validate)는 따로 합니다.
|
||||
function Floor.clean(raw: any): Layout
|
||||
local layout = Floor.default()
|
||||
if typeof(raw) ~= "table" then
|
||||
return layout
|
||||
end
|
||||
if typeof(raw.stove) == "table" then
|
||||
layout.stove = {
|
||||
x = num(raw.stove.x, 0),
|
||||
z = num(raw.stove.z, -26),
|
||||
r = math.floor(num(raw.stove.r, 0)) % 4,
|
||||
}
|
||||
end
|
||||
if typeof(raw.tables) == "table" then
|
||||
layout.tables = {}
|
||||
for _, t in raw.tables do
|
||||
if typeof(t) == "table" then
|
||||
table.insert(layout.tables, { x = num(t.x, 0), z = num(t.z, 0), f = if t.f == 2 then 2 else 1 })
|
||||
end
|
||||
end
|
||||
end
|
||||
if typeof(raw.chairs) == "table" then
|
||||
layout.chairs = {}
|
||||
for _, c in raw.chairs do
|
||||
if typeof(c) == "table" then
|
||||
local t = math.floor(num(c.t, 0))
|
||||
local s = math.floor(num(c.s, 0))
|
||||
if layout.tables[t] and SIDES[s] then
|
||||
table.insert(layout.chairs, { t = t, s = s })
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
if typeof(raw.decor) == "table" then
|
||||
layout.decor = {}
|
||||
for _, d in raw.decor do
|
||||
if typeof(d) == "table" and typeof(d.k) == "string" and Floor.FOOTPRINT[d.k] and d.k ~= "Stove" then
|
||||
table.insert(layout.decor, {
|
||||
k = d.k,
|
||||
x = num(d.x, 0),
|
||||
z = num(d.z, 0),
|
||||
f = if d.f == 2 then 2 else 1,
|
||||
r = math.floor(num(d.r, 0)) % 4,
|
||||
})
|
||||
end
|
||||
end
|
||||
end
|
||||
if #layout.tables == 0 then
|
||||
layout.tables = { { x = -9, z = -10, f = 1 } }
|
||||
end
|
||||
if #layout.chairs == 0 then
|
||||
layout.chairs = { { t = 1, s = 1 } }
|
||||
end
|
||||
return layout
|
||||
end
|
||||
|
||||
-- 새 물건을 놓을 빈 곳 후보(문 가까운 앞쪽부터, 가운데 통로를 비워 두는 순서)
|
||||
local function candidates(f: number): { { x: number, z: number, f: number } }
|
||||
local out = {}
|
||||
local preferred = {
|
||||
{ -9, -10 },
|
||||
{ 9, -10 },
|
||||
{ -9, 4 },
|
||||
{ 9, 4 },
|
||||
{ -23, -10 },
|
||||
{ 23, -10 },
|
||||
{ -23, 4 },
|
||||
{ 23, 4 },
|
||||
{ -9, -20 },
|
||||
{ 9, -20 },
|
||||
{ -23, -22 },
|
||||
{ 23, -22 },
|
||||
{ -23, -32 },
|
||||
{ 23, -32 },
|
||||
}
|
||||
for _, p in preferred do
|
||||
table.insert(out, { x = p[1], z = p[2], f = f })
|
||||
end
|
||||
for z = Floor.Z1 - 3, Floor.Z0 + 3, -2 do
|
||||
for _, sx in { 1, -1 } do
|
||||
for x = 7, Floor.X1 - 2, 2 do
|
||||
table.insert(out, { x = x * sx, z = z, f = f })
|
||||
end
|
||||
end
|
||||
end
|
||||
return out
|
||||
end
|
||||
|
||||
-- 새 테이블(+의자 1개)을 놓을 곳을 찾아 layout에 넣습니다. 놓으면 테이블 번호를 돌려줍니다.
|
||||
function Floor.addTable(layout: Layout, stage: number): number?
|
||||
local floors = if stage >= 3 then { 1, 2 } else { 1 }
|
||||
for _, f in floors do
|
||||
for _, c in candidates(f) do
|
||||
local test = Floor.clone(layout)
|
||||
table.insert(test.tables, { x = c.x, z = c.z, f = c.f })
|
||||
local ti = #test.tables
|
||||
for _, s in { 1, 3, 2, 4 } do
|
||||
test.chairs[#layout.chairs + 1] = { t = ti, s = s }
|
||||
if Floor.validate(test, stage) == nil then
|
||||
layout.tables = test.tables
|
||||
layout.chairs = test.chairs
|
||||
return ti
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
return nil
|
||||
end
|
||||
|
||||
-- 의자 1개를 빈 쪽에 붙입니다(table을 주면 그 테이블 먼저). 놓은 의자 번호를 돌려줍니다.
|
||||
function Floor.addChair(layout: Layout, stage: number, prefer: number?): number?
|
||||
local order = {}
|
||||
if prefer and layout.tables[prefer] then
|
||||
table.insert(order, prefer)
|
||||
end
|
||||
for i in layout.tables do
|
||||
if i ~= prefer then
|
||||
table.insert(order, i)
|
||||
end
|
||||
end
|
||||
for _, ti in order do
|
||||
for _, s in { 1, 3, 2, 4 } do
|
||||
local test = Floor.clone(layout)
|
||||
table.insert(test.chairs, { t = ti, s = s })
|
||||
if Floor.validate(test, stage) == nil then
|
||||
layout.chairs = test.chairs
|
||||
return #layout.chairs
|
||||
end
|
||||
end
|
||||
end
|
||||
return nil
|
||||
end
|
||||
|
||||
function Floor.addDecor(layout: Layout, stage: number, kind: string): number?
|
||||
if not Floor.FOOTPRINT[kind] or kind == "Stove" then
|
||||
return nil
|
||||
end
|
||||
local floors = if stage >= 3 then { 1, 2 } else { 1 }
|
||||
for _, f in floors do
|
||||
-- 소품은 벽 쪽부터 찾습니다.
|
||||
local list = {}
|
||||
for z = Floor.Z0 + 2, Floor.Z1 - 2, 2 do
|
||||
table.insert(list, { x = Floor.X0 + 2, z = z })
|
||||
table.insert(list, { x = Floor.X1 - 2, z = z })
|
||||
end
|
||||
for x = Floor.X0 + 4, Floor.X1 - 4, 2 do
|
||||
table.insert(list, { x = x, z = Floor.Z0 + 2 })
|
||||
end
|
||||
for _, c in candidates(f) do
|
||||
table.insert(list, { x = c.x, z = c.z })
|
||||
end
|
||||
for _, c in list do
|
||||
local test = Floor.clone(layout)
|
||||
table.insert(test.decor, { k = kind, x = c.x, z = c.z, f = f, r = 0 })
|
||||
if Floor.validate(test, stage) == nil then
|
||||
layout.decor = test.decor
|
||||
return #layout.decor
|
||||
end
|
||||
end
|
||||
end
|
||||
return nil
|
||||
end
|
||||
|
||||
-- 물건 하나를 옮긴 새 배치를 만들어 검사합니다. 문제없으면 (새 배치, nil), 아니면 (nil, 이유)
|
||||
-- kind: "stove" | "table" | "decor" | "chair"(chair는 s만 바꿈: x 자리에 쪽 번호)
|
||||
export type Move = { kind: string, i: number, x: number, z: number, f: number?, r: number? }
|
||||
|
||||
function Floor.move(layout: Layout, stage: number, m: Move): (Layout?, string?)
|
||||
local test = Floor.clone(layout)
|
||||
local x = math.floor(m.x * 2 + 0.5) / 2 -- 0.5 stud 단위
|
||||
local z = math.floor(m.z * 2 + 0.5) / 2
|
||||
local f = if m.f == 2 then 2 else 1
|
||||
local r = math.floor(m.r or 0) % 4
|
||||
if m.kind == "stove" then
|
||||
test.stove = { x = x, z = z, r = r }
|
||||
elseif m.kind == "table" then
|
||||
local t = test.tables[m.i]
|
||||
if not t then
|
||||
return nil, "none"
|
||||
end
|
||||
test.tables[m.i] = { x = x, z = z, f = f }
|
||||
elseif m.kind == "decor" then
|
||||
local d = test.decor[m.i]
|
||||
if not d then
|
||||
return nil, "none"
|
||||
end
|
||||
test.decor[m.i] = { k = d.k, x = x, z = z, f = f, r = r }
|
||||
elseif m.kind == "chair" then
|
||||
local c = test.chairs[m.i]
|
||||
local s = math.floor(m.x)
|
||||
if not c or not SIDES[s] then
|
||||
return nil, "none"
|
||||
end
|
||||
-- 다른 테이블로 옮길 수도 있음(z 자리에 테이블 번호, 0이면 그대로)
|
||||
local t = math.floor(m.z)
|
||||
if t ~= 0 then
|
||||
if not test.tables[t] then
|
||||
return nil, "none"
|
||||
end
|
||||
c.t = t
|
||||
end
|
||||
c.s = s
|
||||
else
|
||||
return nil, "none"
|
||||
end
|
||||
local why = Floor.validate(test, stage)
|
||||
if why then
|
||||
return nil, why
|
||||
end
|
||||
return test, nil
|
||||
end
|
||||
|
||||
-- 2층 건물로 올릴 때처럼 배치가 더 이상 맞지 않으면, 문제 있는 물건을 빈 곳으로 옮깁니다.
|
||||
function Floor.repair(layout: Layout, stage: number): Layout
|
||||
if Floor.validate(layout, stage) == nil then
|
||||
return layout
|
||||
end
|
||||
local fixed = Floor.clone(layout)
|
||||
-- 조리대가 문제면 기본 자리로
|
||||
local reserved = Floor.reserved(stage)
|
||||
local function bad(rect: Rect): boolean
|
||||
if not inBounds(rect) or (rect.f == 2 and stage < 3) then
|
||||
return true
|
||||
end
|
||||
for _, r in reserved do
|
||||
if overlap(rect, r) then
|
||||
return true
|
||||
end
|
||||
end
|
||||
return false
|
||||
end
|
||||
local pieces = Floor.pieces(fixed)
|
||||
if bad(pieces[1].rect) then
|
||||
fixed.stove = Floor.default().stove
|
||||
end
|
||||
-- 문제 있는 테이블(또는 그 의자)·소품을 빼고 다시 놓습니다.
|
||||
local movedTables: { number } = {}
|
||||
local tableBad: { [number]: boolean } = {}
|
||||
for _, p in pieces do
|
||||
if (p.kind == "table" or p.kind == "chair") and bad(p.rect) then
|
||||
local ti = if p.kind == "table" then p.index else fixed.chairs[p.index].t
|
||||
tableBad[ti] = true
|
||||
end
|
||||
end
|
||||
for i in fixed.tables do
|
||||
if tableBad[i] then
|
||||
table.insert(movedTables, i)
|
||||
end
|
||||
end
|
||||
for _, ti in movedTables do
|
||||
-- 그 테이블을 아무도 안 쓰는 먼 곳에 잠깐 두고, 빈 곳을 찾아 옮깁니다.
|
||||
local chairsOf = {}
|
||||
for ci, c in fixed.chairs do
|
||||
if c.t == ti then
|
||||
table.insert(chairsOf, ci)
|
||||
end
|
||||
end
|
||||
local placed = false
|
||||
local floors = if stage >= 3 then { 2, 1 } else { 1 }
|
||||
for _, f in floors do
|
||||
if placed then
|
||||
break
|
||||
end
|
||||
for _, c in candidates(f) do
|
||||
local test = Floor.clone(fixed)
|
||||
test.tables[ti] = { x = c.x, z = c.z, f = f }
|
||||
local ok = true
|
||||
for _, ci in chairsOf do
|
||||
local found = false
|
||||
for _, s in { 1, 3, 2, 4 } do
|
||||
test.chairs[ci] = { t = ti, s = s }
|
||||
-- 의자끼리 같은 쪽이면 안 되므로 다른 의자와 비교
|
||||
local dup = false
|
||||
for _, cj in chairsOf do
|
||||
if cj < ci and test.chairs[cj].s == s then
|
||||
dup = true
|
||||
end
|
||||
end
|
||||
if not dup then
|
||||
found = true
|
||||
break
|
||||
end
|
||||
end
|
||||
ok = ok and found
|
||||
end
|
||||
if ok and Floor.validate(test, stage) == nil then
|
||||
fixed = test
|
||||
placed = true
|
||||
break
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
-- 소품은 맞지 않으면 다시 놓고, 놓을 곳이 없으면 뺍니다.
|
||||
local decor = fixed.decor
|
||||
fixed.decor = {}
|
||||
for _, d in decor do
|
||||
local test = Floor.clone(fixed)
|
||||
table.insert(test.decor, d)
|
||||
if Floor.validate(test, stage) == nil then
|
||||
fixed.decor = test.decor
|
||||
else
|
||||
Floor.addDecor(fixed, stage, d.k)
|
||||
end
|
||||
end
|
||||
return fixed
|
||||
end
|
||||
|
||||
-- 손님 길: 부지 입구 -> 문 -> (계단) -> 의자. 꺾이는 점들만 돌려줍니다.
|
||||
local function gridPath(g: Grid, ax: number, az: number, bx: number, bz: number): { { x: number, z: number } }?
|
||||
local si, sj = cellOf(ax, az)
|
||||
local ti, tj = cellOf(bx, bz)
|
||||
if not inGrid(si, sj) or not inGrid(ti, tj) then
|
||||
return nil
|
||||
end
|
||||
local startK = key(si, sj)
|
||||
local goalK = key(ti, tj)
|
||||
local prev: { [number]: number } = { [startK] = -1 }
|
||||
local qi, qj = { si }, { sj }
|
||||
local h = 1
|
||||
local found = startK == goalK
|
||||
while h <= #qi and not found do
|
||||
local i, j = qi[h], qj[h]
|
||||
h += 1
|
||||
for _, d in SIDES do
|
||||
local ni, nj = i + d.x, j + d.z
|
||||
local k = key(ni, nj)
|
||||
if inGrid(ni, nj) and prev[k] == nil and (not g[k] or k == goalK) then
|
||||
prev[k] = key(i, j)
|
||||
if k == goalK then
|
||||
found = true
|
||||
break
|
||||
end
|
||||
table.insert(qi, ni)
|
||||
table.insert(qj, nj)
|
||||
end
|
||||
end
|
||||
end
|
||||
if not found then
|
||||
return nil
|
||||
end
|
||||
local cells = {}
|
||||
local k = goalK
|
||||
while k ~= -1 do
|
||||
table.insert(cells, 1, k)
|
||||
k = prev[k]
|
||||
end
|
||||
-- 칸 경로를 직선으로 이어도 막힌 칸을 지나지 않는 점만 남깁니다.
|
||||
local function clear(k1: number, k2: number): boolean
|
||||
local i1, j1 = k1 % NX, k1 // NX
|
||||
local i2, j2 = k2 % NX, k2 // NX
|
||||
local steps = math.max(math.abs(i2 - i1), math.abs(j2 - j1)) * 3
|
||||
for s = 1, steps - 1 do
|
||||
local t = s / steps
|
||||
local ci = math.floor(i1 + 0.5 + (i2 - i1) * t)
|
||||
local cj = math.floor(j1 + 0.5 + (j2 - j1) * t)
|
||||
local kk = key(ci, cj)
|
||||
if g[kk] and kk ~= goalK and kk ~= startK then
|
||||
return false
|
||||
end
|
||||
end
|
||||
return true
|
||||
end
|
||||
local out = {}
|
||||
local anchor = 1
|
||||
table.insert(out, cells[1])
|
||||
local i = 2
|
||||
while i <= #cells do
|
||||
if i == #cells or not clear(cells[anchor], cells[i + 1]) then
|
||||
table.insert(out, cells[i])
|
||||
anchor = i
|
||||
end
|
||||
i += 1
|
||||
end
|
||||
local pts = {}
|
||||
for idx, kk in out do
|
||||
local cx, cz = cellCenter(kk % NX, kk // NX)
|
||||
if idx == 1 then
|
||||
cx, cz = ax, az
|
||||
elseif idx == #out then
|
||||
cx, cz = bx, bz
|
||||
end
|
||||
table.insert(pts, { x = cx, z = cz })
|
||||
end
|
||||
return pts
|
||||
end
|
||||
|
||||
-- 입구에서 의자까지 손님이 걷는 점들(층 포함). 못 찾으면 직선으로라도 이어 줍니다.
|
||||
function Floor.pathToChair(layout: Layout, stage: number, chair: number): { Pos }
|
||||
local target = Floor.chairPos(layout, chair)
|
||||
local out: { Pos } = { Floor.ENTRANCE, { x = 0, z = 22, f = 1 }, { x = Floor.DOOR.x, z = Floor.DOOR.z, f = 1 } }
|
||||
if not target then
|
||||
return out
|
||||
end
|
||||
local g1 = buildGrid(layout, stage, 1)
|
||||
local function append(g: Grid, f: number, ax: number, az: number, bx: number, bz: number)
|
||||
local pts = gridPath(g, ax, az, bx, bz)
|
||||
if not pts then
|
||||
table.insert(out, { x = bx, z = bz, f = f })
|
||||
return
|
||||
end
|
||||
for i = 2, #pts do
|
||||
table.insert(out, { x = pts[i].x, z = pts[i].z, f = f })
|
||||
end
|
||||
end
|
||||
-- 의자 바로 앞(테이블 반대쪽, 없으면 옆) 빈칸까지 걸어간 뒤 의자에 앉습니다.
|
||||
local function approach(g: Grid): (number, number)
|
||||
local c = layout.chairs[chair]
|
||||
local back = SIDES[c.s]
|
||||
local dirs = { back, { x = back.z, z = back.x }, { x = -back.z, z = -back.x } }
|
||||
local dist = Floor.CHAIR_SIZE / 2 + 0.6
|
||||
for _, d in dirs do
|
||||
local ax, az = target.x + d.x * dist, target.z + d.z * dist
|
||||
local i, j = cellOf(ax, az)
|
||||
if inGrid(i, j) and not g[key(i, j)] then
|
||||
return ax, az
|
||||
end
|
||||
end
|
||||
return target.x + back.x * dist, target.z + back.z * dist
|
||||
end
|
||||
local doorIn = Floor.DOOR.z - 0.6
|
||||
table.insert(out, { x = Floor.DOOR.x, z = doorIn, f = 1 })
|
||||
if target.f == 1 then
|
||||
local ax, az = approach(g1)
|
||||
append(g1, 1, Floor.DOOR.x, doorIn, ax, az)
|
||||
else
|
||||
local b = Floor.STAIR_BOTTOM
|
||||
local t = Floor.STAIR_TOP
|
||||
append(g1, 1, Floor.DOOR.x, doorIn, b.x, b.z + 1.5)
|
||||
table.insert(out, { x = b.x, z = b.z, f = 1 })
|
||||
table.insert(out, { x = t.x, z = t.z, f = 2 })
|
||||
local g2 = buildGrid(layout, stage, 2)
|
||||
local ax, az = approach(g2)
|
||||
append(g2, 2, t.x, t.z - 1.5, ax, az)
|
||||
end
|
||||
table.insert(out, target)
|
||||
return out
|
||||
end
|
||||
|
||||
-- 길 길이(stud). 층 사이는 계단 길이로 셉니다.
|
||||
function Floor.pathLength(path: { Pos }): number
|
||||
local total = 0
|
||||
for i = 2, #path do
|
||||
local a, b = path[i - 1], path[i]
|
||||
local dy = (b.f - a.f) * Floor.FLOOR2_Y
|
||||
total += math.sqrt((b.x - a.x) ^ 2 + (b.z - a.z) ^ 2 + dy * dy)
|
||||
end
|
||||
return total
|
||||
end
|
||||
|
||||
return Floor
|
||||
@@ -1,15 +1,16 @@
|
||||
--!strict
|
||||
-- 가게 한 곳의 규칙(손님, 주문, 조리, 서빙, 돈, 구매)을 담은 순수 로직입니다.
|
||||
-- 가게 한 곳의 규칙(손님, 주문, 조리, 서빙, 돈, 업그레이드, 알바생, 시급)을 담은 순수 로직입니다.
|
||||
-- 로블록스 API를 쓰지 않아서 lune 단위 테스트와 시뮬레이터에서 그대로 돌립니다.
|
||||
-- 화면(NPC, 접시 모형, 효과)은 서버의 PlotController가 이벤트를 받아 그립니다.
|
||||
-- 테이블·의자 위치는 모릅니다. 자리 수(seats)와 자리별 걷는 시간(seatWalk)만 압니다.
|
||||
|
||||
-- 로블록스에서는 script.Parent, lune(테스트)에서는 파일 경로로 불러옵니다.
|
||||
local Economy: typeof(require(script.Parent.Economy)) = if script
|
||||
then require(script.Parent.Economy)
|
||||
else (require :: any)("./Economy")
|
||||
|
||||
type Stats = typeof(Economy.statsAt(0))
|
||||
type Purchase = typeof(Economy.PURCHASES[1])
|
||||
type Stats = Economy.Stats
|
||||
type Levels = Economy.Levels
|
||||
|
||||
export type CustomerState = "walking" | "waiting" | "eating"
|
||||
|
||||
@@ -20,47 +21,89 @@ export type Customer = {
|
||||
state: CustomerState,
|
||||
untilT: number, -- walking/eating이 끝나는 시각. 플레이어 손님은 기다리다 일어나는 시각
|
||||
guest: number?, -- 다른 플레이어가 손님으로 왔으면 그 UserId
|
||||
transfer: boolean?, -- 옆 가게에서 데려온 손님
|
||||
}
|
||||
|
||||
-- 서빙 알바가 나르는 중인 접시
|
||||
export type Trip = {
|
||||
staff: number, -- 서빙 알바 번호(1부터)
|
||||
id: number, -- 손님 id
|
||||
menu: string,
|
||||
doneT: number,
|
||||
}
|
||||
|
||||
export type Event =
|
||||
{ kind: "spawn", id: number, seat: number, menu: string }
|
||||
{ kind: "spawn", id: number, seat: number, menu: string, transfer: boolean? }
|
||||
| { kind: "seated", id: number }
|
||||
| { kind: "leave", id: number, seat: number, guest: number?, served: boolean }
|
||||
| { kind: "counter", menu: string }
|
||||
| { kind: "counter", menu: string, staff: number }
|
||||
| { kind: "deliver", id: number, menu: string, staff: number, index: number }
|
||||
| { kind: "delivered", id: number, staff: number, earn: number }
|
||||
| { kind: "returned", menu: string, staff: number }
|
||||
| { kind: "wage", amount: number }
|
||||
| { kind: "strike", on: boolean }
|
||||
|
||||
export type Shop = {
|
||||
money: number,
|
||||
bought: number,
|
||||
moneyMult: number,
|
||||
levels: Levels,
|
||||
stats: Stats,
|
||||
moneyMult: number,
|
||||
customers: { [number]: Customer },
|
||||
seatTaken: { [number]: number },
|
||||
seatWalk: { [number]: number }, -- 자리별 입구 -> 자리 걷는 시간
|
||||
hand: { string },
|
||||
counter: { string },
|
||||
trips: { [number]: Trip }, -- 서빙 알바 번호 -> 나르는 중
|
||||
staff: Economy.Staff,
|
||||
strike: boolean, -- 시급이 모자라 알바생이 쉬는 중
|
||||
wageDue: number, -- 다음 시급 주는 시각
|
||||
cookNext: { [number]: number }, -- 요리 알바 번호 -> 다음에 만들 수 있는 시각
|
||||
rushLeft: number, -- 손님 러시 남은 초
|
||||
now: number,
|
||||
nextSpawn: number,
|
||||
nextHelper: number,
|
||||
menuIndex: number,
|
||||
lastId: number,
|
||||
served: number,
|
||||
earned: number,
|
||||
}
|
||||
|
||||
export type Options = {
|
||||
money: number,
|
||||
levels: Levels?,
|
||||
seats: number?,
|
||||
staff: Economy.Staff?,
|
||||
now: number,
|
||||
rushLeft: number?,
|
||||
}
|
||||
|
||||
local Shop = {}
|
||||
|
||||
function Shop.new(money: number, bought: number, now: number): Shop
|
||||
function Shop.new(opts: Options): Shop
|
||||
local levels = Economy.cleanLevels(opts.levels)
|
||||
local seats = math.max(1, opts.seats or 1)
|
||||
local staff: Economy.Staff = {}
|
||||
for _, r in Economy.ROLES do
|
||||
local n = if opts.staff then opts.staff[r.id] else nil
|
||||
staff[r.id] = if typeof(n) == "number" then math.clamp(math.floor(n), 0, r.max) else 0
|
||||
end
|
||||
return {
|
||||
money = money,
|
||||
bought = math.clamp(bought, 0, #Economy.PURCHASES),
|
||||
money = opts.money,
|
||||
levels = levels,
|
||||
stats = Economy.stats(levels, seats),
|
||||
moneyMult = 1,
|
||||
stats = Economy.statsAt(bought),
|
||||
customers = {},
|
||||
seatTaken = {},
|
||||
seatWalk = {},
|
||||
hand = {},
|
||||
counter = {},
|
||||
now = now,
|
||||
nextSpawn = now, -- 접속하자마자 첫 손님
|
||||
nextHelper = now,
|
||||
trips = {},
|
||||
staff = staff,
|
||||
strike = false,
|
||||
wageDue = opts.now + Economy.WAGE_PERIOD,
|
||||
cookNext = {},
|
||||
rushLeft = math.max(0, opts.rushLeft or 0),
|
||||
now = opts.now,
|
||||
nextSpawn = opts.now, -- 접속하자마자 첫 손님
|
||||
menuIndex = 0,
|
||||
lastId = 0,
|
||||
served = 0,
|
||||
@@ -68,7 +111,14 @@ function Shop.new(money: number, bought: number, now: number): Shop
|
||||
}
|
||||
end
|
||||
|
||||
local function freeSeat(self: Shop): number?
|
||||
local function staffWorking(self: Shop, role: string): number
|
||||
if self.strike or not self.stats.staffUnlocked then
|
||||
return 0
|
||||
end
|
||||
return self.staff[role] or 0
|
||||
end
|
||||
|
||||
function Shop.freeSeat(self: Shop): number?
|
||||
for seat = 1, self.stats.seats do
|
||||
if self.seatTaken[seat] == nil then
|
||||
return seat
|
||||
@@ -77,8 +127,48 @@ local function freeSeat(self: Shop): number?
|
||||
return nil
|
||||
end
|
||||
|
||||
-- 다음 손님이 주문할 메뉴(해금된 메뉴를 돌아가며)
|
||||
function Shop.freeSeatCount(self: Shop): number
|
||||
local n = 0
|
||||
for seat = 1, self.stats.seats do
|
||||
if self.seatTaken[seat] == nil then
|
||||
n += 1
|
||||
end
|
||||
end
|
||||
return n
|
||||
end
|
||||
|
||||
-- 손에 든 접시·카운터·나르는 중인 접시 중 기다리는 손님이 없는 메뉴(주인 없는 접시).
|
||||
-- 손님이 옆 가게로 가 버려서 남은 접시입니다. 다음 손님이 이 메뉴를 주문하게 해서 접시가 버려지지 않게 합니다.
|
||||
local function orphanMenu(self: Shop): string?
|
||||
local have: { [string]: number } = {}
|
||||
for _, m in self.hand do
|
||||
have[m] = (have[m] or 0) + 1
|
||||
end
|
||||
for _, m in self.counter do
|
||||
have[m] = (have[m] or 0) + 1
|
||||
end
|
||||
for _, t in self.trips do
|
||||
have[t.menu] = (have[t.menu] or 0) + 1
|
||||
end
|
||||
for _, c in self.customers do
|
||||
if c.state ~= "eating" and have[c.menu] then
|
||||
have[c.menu] -= 1
|
||||
end
|
||||
end
|
||||
for _, m in Economy.MENU_ORDER do
|
||||
if (have[m] or 0) > 0 and table.find(self.stats.menus, m) then
|
||||
return m
|
||||
end
|
||||
end
|
||||
return nil
|
||||
end
|
||||
|
||||
-- 다음 손님이 주문할 메뉴(주인 없는 접시가 있으면 그 메뉴, 아니면 해금된 메뉴를 돌아가며)
|
||||
local function nextOrder(self: Shop): string
|
||||
local orphan = orphanMenu(self)
|
||||
if orphan then
|
||||
return orphan
|
||||
end
|
||||
local menus = self.stats.menus
|
||||
local menu = menus[(self.menuIndex % #menus) + 1]
|
||||
self.menuIndex += 1
|
||||
@@ -94,9 +184,13 @@ function Shop.openOrders(self: Shop): { Customer }
|
||||
for _, m in self.counter do
|
||||
covered[m] = (covered[m] or 0) + 1
|
||||
end
|
||||
local tripFor: { [number]: boolean } = {}
|
||||
for _, t in self.trips do
|
||||
tripFor[t.id] = true
|
||||
end
|
||||
local list = {}
|
||||
for _, c in self.customers do
|
||||
if c.state ~= "eating" then
|
||||
if c.state ~= "eating" and not tripFor[c.id] then
|
||||
table.insert(list, c)
|
||||
end
|
||||
end
|
||||
@@ -134,10 +228,71 @@ function Shop.handFull(self: Shop): boolean
|
||||
return #self.hand >= self.stats.carry
|
||||
end
|
||||
|
||||
function Shop.spawnInterval(self: Shop): number
|
||||
return Economy.spawnInterval(self.stats, staffWorking(self, "Promoter"), self.rushLeft > 0)
|
||||
end
|
||||
|
||||
local function addCustomer(self: Shop, seat: number, menu: string, walk: number, transfer: boolean?): Customer
|
||||
self.lastId += 1
|
||||
local c: Customer = {
|
||||
id = self.lastId,
|
||||
seat = seat,
|
||||
menu = menu,
|
||||
state = "walking",
|
||||
untilT = self.now + walk,
|
||||
transfer = transfer,
|
||||
}
|
||||
self.customers[c.id] = c
|
||||
self.seatTaken[seat] = c.id
|
||||
return c
|
||||
end
|
||||
|
||||
-- 손님 자리까지 서빙 알바가 가는 시간
|
||||
local function tripTime(self: Shop, seat: number): number
|
||||
local walk = self.seatWalk[seat] or Economy.WALK_IN
|
||||
return math.max(1.5, Economy.SERVER_TRIP * walk / Economy.WALK_IN)
|
||||
end
|
||||
|
||||
local function payWages(self: Shop, now: number, events: { Event })
|
||||
if now < self.wageDue then
|
||||
return
|
||||
end
|
||||
local total = Economy.totalWage(self.staff, self.stats)
|
||||
if total <= 0 or not self.stats.staffUnlocked then
|
||||
self.wageDue = now + Economy.WAGE_PERIOD
|
||||
if self.strike then
|
||||
self.strike = false
|
||||
table.insert(events, { kind = "strike", on = false } :: Event)
|
||||
end
|
||||
return
|
||||
end
|
||||
if self.money >= total then
|
||||
self.money -= total
|
||||
self.wageDue = now + Economy.WAGE_PERIOD
|
||||
table.insert(events, { kind = "wage", amount = total } :: Event)
|
||||
if self.strike then
|
||||
self.strike = false
|
||||
table.insert(events, { kind = "strike", on = false } :: Event)
|
||||
end
|
||||
else
|
||||
self.wageDue = now + Economy.STRIKE_RETRY
|
||||
if not self.strike then
|
||||
self.strike = true
|
||||
table.insert(events, { kind = "strike", on = true } :: Event)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
-- 시간을 now까지 진행합니다. 일어난 일을 이벤트로 돌려줍니다.
|
||||
function Shop.tick(self: Shop, now: number): { Event }
|
||||
local dt = math.max(0, now - self.now)
|
||||
self.now = now
|
||||
local events: { Event } = {}
|
||||
if self.rushLeft > 0 then
|
||||
self.rushLeft = math.max(0, self.rushLeft - dt)
|
||||
end
|
||||
|
||||
payWages(self, now, events)
|
||||
|
||||
for id, c in self.customers do
|
||||
if c.state == "walking" and now >= c.untilT then
|
||||
@@ -155,36 +310,88 @@ function Shop.tick(self: Shop, now: number): { Event }
|
||||
end
|
||||
|
||||
if now >= self.nextSpawn then
|
||||
local seat = freeSeat(self)
|
||||
local seat = Shop.freeSeat(self)
|
||||
if seat then
|
||||
self.lastId += 1
|
||||
local menu = nextOrder(self)
|
||||
local c: Customer = {
|
||||
id = self.lastId,
|
||||
seat = seat,
|
||||
menu = menu,
|
||||
state = "walking",
|
||||
untilT = now + Economy.WALK_IN,
|
||||
}
|
||||
self.customers[c.id] = c
|
||||
self.seatTaken[seat] = c.id
|
||||
local c = addCustomer(self, seat, menu, self.seatWalk[seat] or Economy.WALK_IN)
|
||||
table.insert(events, { kind = "spawn", id = c.id, seat = seat, menu = menu } :: Event)
|
||||
end
|
||||
self.nextSpawn = now + self.stats.spawn
|
||||
self.nextSpawn = now + Shop.spawnInterval(self)
|
||||
end
|
||||
|
||||
if self.stats.helper and now >= self.nextHelper then
|
||||
local menu = Shop.nextCookMenu(self)
|
||||
if menu and #self.counter < Economy.COUNTER_MAX then
|
||||
table.insert(self.counter, menu)
|
||||
table.insert(events, { kind = "counter", menu = menu } :: Event)
|
||||
self.nextHelper = now + self.stats.cook
|
||||
-- 요리 알바: 한 명마다 조리 수준(초)에 한 접시씩 카운터에 만들어 둡니다.
|
||||
local cooks = staffWorking(self, "Cook")
|
||||
for i = 1, cooks do
|
||||
if now >= (self.cookNext[i] or 0) and #self.counter < Economy.COUNTER_MAX * cooks then
|
||||
local menu = Shop.nextCookMenu(self)
|
||||
if menu then
|
||||
table.insert(self.counter, menu)
|
||||
table.insert(events, { kind = "counter", menu = menu, staff = i } :: Event)
|
||||
self.cookNext[i] = now + self.stats.cook
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
-- 서빙 알바: 다 나른 접시는 손님에게 놓고, 빈 손이면 카운터 접시를 기다리는 손님에게 가져갑니다.
|
||||
for i, t in self.trips do
|
||||
if now >= t.doneT then
|
||||
self.trips[i] = nil
|
||||
local c = self.customers[t.id]
|
||||
if c and c.state == "waiting" then
|
||||
c.state = "eating"
|
||||
c.untilT = now + Economy.EAT
|
||||
local earn = Shop.pay(self, c)
|
||||
table.insert(events, { kind = "delivered", id = c.id, staff = i, earn = earn } :: Event)
|
||||
else
|
||||
table.insert(self.counter, t.menu)
|
||||
table.insert(events, { kind = "returned", menu = t.menu, staff = i } :: Event)
|
||||
end
|
||||
end
|
||||
end
|
||||
local servers = staffWorking(self, "Server")
|
||||
for i = 1, servers do
|
||||
if not self.trips[i] and #self.counter > 0 then
|
||||
local busy: { [number]: boolean } = {}
|
||||
for _, t in self.trips do
|
||||
busy[t.id] = true
|
||||
end
|
||||
local best: Customer? = nil
|
||||
local bestIdx = 0
|
||||
for _, c in self.customers do
|
||||
if c.state == "waiting" and not busy[c.id] and (not best or c.id < best.id) then
|
||||
local idx = table.find(self.counter, c.menu)
|
||||
if idx then
|
||||
best = c
|
||||
bestIdx = idx
|
||||
end
|
||||
end
|
||||
end
|
||||
if best then
|
||||
table.remove(self.counter, bestIdx)
|
||||
self.trips[i] = { staff = i, id = best.id, menu = best.menu, doneT = now + tripTime(self, best.seat) }
|
||||
table.insert(
|
||||
events,
|
||||
{ kind = "deliver", id = best.id, menu = best.menu, staff = i, index = bestIdx } :: Event
|
||||
)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
return events
|
||||
end
|
||||
|
||||
-- 손님 한 명 값(접시 값, 플레이어 손님이면 2배)을 받습니다.
|
||||
function Shop.pay(self: Shop, c: Customer): number
|
||||
local earn = Economy.dishPrice(c.menu, self.stats, self.moneyMult)
|
||||
if c.guest then
|
||||
earn *= Economy.GUEST_MULT
|
||||
end
|
||||
self.money += earn
|
||||
self.earned += earn
|
||||
self.served += 1
|
||||
return earn
|
||||
end
|
||||
|
||||
-- 플레이어가 요리 화면에서 다 만들었을 때. 만든 메뉴를 돌려줍니다.
|
||||
-- menu를 주면 그 메뉴를 기다리는 주문이 있을 때만 만들고, 없으면 먼저 온 손님 메뉴를 만듭니다.
|
||||
function Shop.cook(self: Shop, menu: string?): string?
|
||||
@@ -204,7 +411,7 @@ function Shop.cook(self: Shop, menu: string?): string?
|
||||
return menu
|
||||
end
|
||||
|
||||
-- 알바생이 만들어 둔 접시를 손에 듭니다. 든 접시 수를 돌려줍니다.
|
||||
-- 요리 알바가 만들어 둔 접시를 손에 듭니다. 든 접시 수를 돌려줍니다.
|
||||
function Shop.pickup(self: Shop): number
|
||||
local n = 0
|
||||
while #self.counter > 0 and not Shop.handFull(self) do
|
||||
@@ -220,6 +427,11 @@ function Shop.serve(self: Shop, id: number): number?
|
||||
if not c or c.state ~= "waiting" then
|
||||
return nil
|
||||
end
|
||||
for _, t in self.trips do
|
||||
if t.id == id then
|
||||
return nil -- 서빙 알바가 가져가는 중
|
||||
end
|
||||
end
|
||||
local idx = table.find(self.hand, c.menu)
|
||||
if not idx then
|
||||
return nil
|
||||
@@ -227,41 +439,143 @@ function Shop.serve(self: Shop, id: number): number?
|
||||
table.remove(self.hand, idx)
|
||||
c.state = "eating"
|
||||
c.untilT = self.now + Economy.EAT
|
||||
local earn = Economy.dishPrice(c.menu, self.stats, self.moneyMult)
|
||||
if c.guest then
|
||||
earn *= Economy.GUEST_MULT
|
||||
return Shop.pay(self, c)
|
||||
end
|
||||
|
||||
-- 돈을 씁니다. 모자라면 false
|
||||
function Shop.spend(self: Shop, cost: number): boolean
|
||||
if cost < 0 or self.money < cost then
|
||||
return false
|
||||
end
|
||||
self.money += earn
|
||||
self.earned += earn
|
||||
self.served += 1
|
||||
return earn
|
||||
self.money -= cost
|
||||
return true
|
||||
end
|
||||
|
||||
function Shop.nextPurchase(self: Shop): Purchase?
|
||||
return Economy.PURCHASES[self.bought + 1]
|
||||
local function refreshStats(self: Shop)
|
||||
local before = self.stats
|
||||
self.stats = Economy.stats(self.levels, before.seats)
|
||||
if self.stats.spawn < before.spawn then
|
||||
self.nextSpawn = math.min(self.nextSpawn, self.now + Shop.spawnInterval(self))
|
||||
end
|
||||
end
|
||||
|
||||
-- 다음 업그레이드를 삽니다. 성공하면 산 항목을 돌려줍니다.
|
||||
function Shop.buyNext(self: Shop): (Purchase?, string?)
|
||||
local p = Shop.nextPurchase(self)
|
||||
if not p then
|
||||
-- 업그레이드 갈래의 다음 단계를 삽니다. 성공하면 산 단계(Level)를 돌려줍니다.
|
||||
-- 실패 이유: "max"(다 삼), "stage"(건물 단계 부족), "money"
|
||||
function Shop.buyLevel(self: Shop, trackId: string): (Economy.Level?, string?)
|
||||
local nl = Economy.nextLevel(self.levels, trackId)
|
||||
if not nl then
|
||||
return nil, "max"
|
||||
end
|
||||
if self.money < p.cost then
|
||||
if nl.stage > self.stats.stage then
|
||||
return nil, "stage"
|
||||
end
|
||||
if not Shop.spend(self, nl.cost) then
|
||||
return nil, "money"
|
||||
end
|
||||
self.money -= p.cost
|
||||
self.bought += 1
|
||||
self.stats = Economy.statsAt(self.bought)
|
||||
if p.effect.spawn then
|
||||
self.nextSpawn = math.min(self.nextSpawn, self.now + p.effect.spawn)
|
||||
end
|
||||
if p.effect.menu then
|
||||
self.levels[trackId] += 1
|
||||
refreshStats(self)
|
||||
if trackId == "Menu" then
|
||||
-- 새 메뉴를 사면 다음 손님이 바로 그 메뉴를 주문해서, 산 효과가 곧바로 보이게 합니다.
|
||||
self.menuIndex = #self.stats.menus - 1
|
||||
self.nextSpawn = math.min(self.nextSpawn, self.now + 1)
|
||||
end
|
||||
return p, nil
|
||||
return nl, nil
|
||||
end
|
||||
|
||||
-- 자리 수가 바뀌었을 때(의자를 사거나 놓음)
|
||||
function Shop.setSeats(self: Shop, seats: number)
|
||||
self.stats = Economy.stats(self.levels, seats)
|
||||
self.stats.seats = math.max(1, seats)
|
||||
-- 새 자리가 생기면 손님이 곧 옵니다.
|
||||
self.nextSpawn = math.min(self.nextSpawn, self.now + 1)
|
||||
end
|
||||
|
||||
-- 알바생 고용·해고. 고용은 고용비를 냅니다. 실패 이유: "locked", "max", "money", "none"
|
||||
function Shop.hire(self: Shop, roleId: string): (boolean, string?)
|
||||
local r = Economy.role(roleId)
|
||||
if not r then
|
||||
return false, "none"
|
||||
end
|
||||
if not self.stats.staffUnlocked then
|
||||
return false, "locked"
|
||||
end
|
||||
if (self.staff[roleId] or 0) >= r.max then
|
||||
return false, "max"
|
||||
end
|
||||
if not Shop.spend(self, r.hire) then
|
||||
return false, "money"
|
||||
end
|
||||
self.staff[roleId] = (self.staff[roleId] or 0) + 1
|
||||
if self.wageDue < self.now then
|
||||
self.wageDue = self.now + Economy.WAGE_PERIOD
|
||||
end
|
||||
if roleId == "Promoter" then
|
||||
self.nextSpawn = math.min(self.nextSpawn, self.now + Shop.spawnInterval(self))
|
||||
end
|
||||
return true, nil
|
||||
end
|
||||
|
||||
function Shop.fire(self: Shop, roleId: string): boolean
|
||||
local n = self.staff[roleId] or 0
|
||||
if n <= 0 then
|
||||
return false
|
||||
end
|
||||
self.staff[roleId] = n - 1
|
||||
if roleId == "Server" and self.trips[n] then
|
||||
-- 나르던 접시는 카운터로 돌려놓습니다.
|
||||
table.insert(self.counter, self.trips[n].menu)
|
||||
self.trips[n] = nil
|
||||
end
|
||||
self.cookNext[n] = nil
|
||||
return true
|
||||
end
|
||||
|
||||
-- 손님 러시(유료): 남은 시간을 늘립니다.
|
||||
function Shop.addRush(self: Shop, seconds: number)
|
||||
self.rushLeft += seconds
|
||||
self.nextSpawn = math.min(self.nextSpawn, self.now + Shop.spawnInterval(self))
|
||||
end
|
||||
|
||||
-- 옆 가게에서 손님을 데려갈 때: 아직 음식을 못 받은(먹는 중이 아닌) NPC 손님을 최대 n명 빼서 돌려줍니다.
|
||||
-- 그 손님 자리로 가던 서빙 알바 접시는 카운터로 돌아갑니다.
|
||||
function Shop.takeCustomers(self: Shop, n: number): { Customer }
|
||||
local list = {}
|
||||
for _, c in self.customers do
|
||||
if c.state ~= "eating" and not c.guest then
|
||||
table.insert(list, c)
|
||||
end
|
||||
end
|
||||
-- 늦게 온 손님부터(오래 기다린 손님은 곧 음식을 받으니까)
|
||||
table.sort(list, function(a, b)
|
||||
return a.id > b.id
|
||||
end)
|
||||
local out = {}
|
||||
for i = 1, math.min(n, #list) do
|
||||
local c = list[i]
|
||||
self.customers[c.id] = nil
|
||||
self.seatTaken[c.seat] = nil
|
||||
for s, t in self.trips do
|
||||
if t.id == c.id then
|
||||
table.insert(self.counter, t.menu)
|
||||
self.trips[s] = nil
|
||||
end
|
||||
end
|
||||
table.insert(out, c)
|
||||
end
|
||||
return out
|
||||
end
|
||||
|
||||
-- 옆 가게에서 온 손님을 빈자리에 앉힙니다(walk초 걸어옴). 자리가 없으면 nil
|
||||
function Shop.addTransfer(self: Shop, menu: string, walk: number): Customer?
|
||||
local seat = Shop.freeSeat(self)
|
||||
if not seat then
|
||||
return nil
|
||||
end
|
||||
-- 우리 가게에 없는 메뉴를 원하던 손님은 우리 메뉴로 바꿔 주문합니다.
|
||||
if not table.find(self.stats.menus, menu) then
|
||||
menu = nextOrder(self)
|
||||
end
|
||||
return addCustomer(self, seat, menu, walk, true)
|
||||
end
|
||||
|
||||
-- 다른 플레이어가 손님으로 와서 빈자리에 앉습니다(걷지 않고 바로 주문). 자리가 없거나 이미 앉아 있으면 nil.
|
||||
@@ -271,21 +585,14 @@ function Shop.addGuest(self: Shop, userId: number): Customer?
|
||||
return nil
|
||||
end
|
||||
end
|
||||
local seat = freeSeat(self)
|
||||
local seat = Shop.freeSeat(self)
|
||||
if not seat then
|
||||
return nil
|
||||
end
|
||||
self.lastId += 1
|
||||
local c: Customer = {
|
||||
id = self.lastId,
|
||||
seat = seat,
|
||||
menu = nextOrder(self),
|
||||
state = "waiting",
|
||||
untilT = self.now + Economy.GUEST_WAIT,
|
||||
guest = userId,
|
||||
}
|
||||
self.customers[c.id] = c
|
||||
self.seatTaken[seat] = c.id
|
||||
local c = addCustomer(self, seat, nextOrder(self), 0)
|
||||
c.state = "waiting"
|
||||
c.untilT = self.now + Economy.GUEST_WAIT
|
||||
c.guest = userId
|
||||
return c
|
||||
end
|
||||
|
||||
|
||||
13
bunsik-tycoon/tests/Codec.spec.luau
Normal file
13
bunsik-tycoon/tests/Codec.spec.luau
Normal file
@@ -0,0 +1,13 @@
|
||||
-- lune run tests/Codec.spec.luau
|
||||
local Codec = require("../src/shared/Codec")
|
||||
local T = require("./check")
|
||||
local s = Codec.encodeMap({ Cook = 1, Server = 2 }, { "Cook", "Server", "Promoter" })
|
||||
T.eq(s, "Cook=1,Server=2,Promoter=0", "encode")
|
||||
local m = Codec.decodeMap(s)
|
||||
T.eq(m.Server, 2, "decode")
|
||||
T.eq(m.Promoter, 0, "decode 0")
|
||||
T.eq(next(Codec.decodeMap(nil)), nil, "nil")
|
||||
T.eq(Codec.decodeMap("Price=1.5").Price, 1.5, "소수")
|
||||
T.eq(#Codec.decodeList("A,B,,C"), 3, "list")
|
||||
T.eq(#Codec.decodeList(""), 0, "빈 list")
|
||||
T.done("Codec.spec")
|
||||
@@ -2,63 +2,101 @@
|
||||
local Economy = require("../src/shared/Economy")
|
||||
local T = require("./check")
|
||||
|
||||
T.eq(#Economy.PURCHASES, 20, "구매 항목은 20개(1단계 10 + 2단계 10)")
|
||||
T.eq(Economy.PURCHASES[10].id, "Expand", "10번째는 실내 확장")
|
||||
T.eq(Economy.PURCHASES[10].effect.stage, 2, "확장하면 2단계")
|
||||
|
||||
local seen = {}
|
||||
local prev = 0
|
||||
for i, p in Economy.PURCHASES do
|
||||
T.check(p.cost > prev, `#{i} {p.id} 비용이 앞 단계보다 커야 함`)
|
||||
prev = p.cost
|
||||
T.check(seen[p.id] == nil, `#{i} {p.id} id 중복`)
|
||||
seen[p.id] = true
|
||||
if p.effect.menu then
|
||||
T.check(Economy.MENUS[p.effect.menu] ~= nil, `#{i} 없는 메뉴 {p.effect.menu}`)
|
||||
-- 갈래마다 단계 값이 오르고 필요한 건물 단계가 내려가지 않음
|
||||
for _, t in Economy.TRACKS do
|
||||
local prevCost, prevStage = 0, 1
|
||||
for i, l in t.levels do
|
||||
T.check(l.cost > prevCost, `{t.id}{i} 비용이 앞 단계보다 커야 함`)
|
||||
T.check(l.stage >= prevStage, `{t.id}{i} 필요 단계가 줄지 않음`)
|
||||
prevCost, prevStage = l.cost, l.stage
|
||||
if t.id == "Menu" then
|
||||
T.check(Economy.MENUS[l.value] ~= nil, `없는 메뉴 {l.value}`)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
for _, key in Economy.MENU_ORDER do
|
||||
T.check(Economy.MENUS[key] ~= nil, `메뉴 순서의 {key}`)
|
||||
end
|
||||
|
||||
local s0 = Economy.statsAt(0)
|
||||
T.eq(s0.seats, 1, "처음 테이블 1")
|
||||
T.eq(s0.spawn, 6, "처음 손님 간격 6초")
|
||||
T.eq(s0.cook, 2.5, "처음 조리 2.5초")
|
||||
local lv0 = Economy.emptyLevels()
|
||||
local s0 = Economy.stats(lv0, 1)
|
||||
T.eq(s0.seats, 1, "처음 자리 1")
|
||||
T.eq(s0.spawn, 10, "처음 손님 간격 10초(예전 6초보다 느림)")
|
||||
T.eq(s0.cook, 2.5, "처음 조리 2.5")
|
||||
T.eq(#s0.menus, 1, "처음 메뉴 1개")
|
||||
T.eq(s0.carry, 1, "처음 접시 1개")
|
||||
T.eq(s0.stage, 1, "처음 포장마차")
|
||||
T.eq(s0.staffUnlocked, false, "처음엔 알바생 잠김")
|
||||
|
||||
local s10 = Economy.statsAt(10)
|
||||
T.eq(s10.seats, 4, "10개 산 뒤 테이블 4")
|
||||
T.eq(s10.spawn, 4, "10개 산 뒤 손님 간격 4초")
|
||||
T.eq(s10.helper, true, "10개 산 뒤 알바생")
|
||||
T.eq(s10.stage, 2, "10개 산 뒤 2단계")
|
||||
T.eq(#s10.menus, 3, "10개 산 뒤 메뉴 3개")
|
||||
local all = Economy.emptyLevels()
|
||||
for _, t in Economy.TRACKS do
|
||||
all[t.id] = #t.levels
|
||||
end
|
||||
local sAll = Economy.stats(all, 24)
|
||||
T.eq(sAll.stage, 3, "다 사면 2층")
|
||||
T.eq(#sAll.menus, 5, "메뉴 5개")
|
||||
T.eq(sAll.carry, 3, "접시 3개")
|
||||
T.eq(sAll.staffUnlocked, true, "알바생 열림")
|
||||
T.eq(Economy.stats(Economy.cleanLevels({ Menu = 99, Bad = 3 }), 1).menus[5], "Twigim", "범위를 넘어도 안전")
|
||||
T.eq(Economy.cleanLevels({ Menu = 99 }).Menu, 4, "레벨은 최대값으로 자름")
|
||||
|
||||
local s20 = Economy.statsAt(20)
|
||||
T.eq(s20.seats, Economy.MAX_SEATS, "전부 산 뒤 테이블 8")
|
||||
T.eq(s20.carry, 3, "전부 산 뒤 접시 3개")
|
||||
T.eq(#s20.menus, 5, "전부 산 뒤 메뉴 5개")
|
||||
T.eq(Economy.statsAt(99).seats, 8, "범위를 넘어도 안전")
|
||||
|
||||
-- statsAt은 START를 바꾸면 안 됨
|
||||
Economy.statsAt(20)
|
||||
T.eq(#Economy.START.menus, 1, "START.menus 불변")
|
||||
-- stats는 START_MENUS를 바꾸면 안 됨
|
||||
Economy.stats(all, 1)
|
||||
T.eq(#Economy.START_MENUS, 1, "START_MENUS 불변")
|
||||
|
||||
T.eq(Economy.dishPrice("Tteokbokki", s0, 1), 15, "떡볶이 15")
|
||||
T.eq(Economy.dishPrice("Gimbap", Economy.statsAt(7), 1), 37, "김밥 25 x 1.5 = 37(내림)")
|
||||
local p2 = Economy.stats(Economy.cleanLevels({ Price = 2 }), 1)
|
||||
T.eq(Economy.dishPrice("Gimbap", p2, 1), 37, "김밥 25 x 1.5 = 37(내림)")
|
||||
T.eq(Economy.dishPrice("Tteokbokki", s0, 2), 30, "2배 수익")
|
||||
|
||||
T.eq(
|
||||
Economy.boostAmount(s0),
|
||||
math.max(Economy.BOOST_MIN, Economy.incomePerMinute(s0) * 10),
|
||||
"부스트 = 1분 매출 x 10분"
|
||||
)
|
||||
T.check(
|
||||
Economy.incomePerMinute(s0) >= 30 and Economy.incomePerMinute(s0) <= 60,
|
||||
"처음 1분 매출 30~60원(시뮬레이터와 비슷)"
|
||||
)
|
||||
T.check(Economy.boostAmount(s20) > Economy.boostAmount(s10), "후반일수록 부스트가 큼")
|
||||
-- 자리 값
|
||||
T.eq(Economy.seatCost(1), 0, "첫 자리 공짜")
|
||||
T.eq(Economy.seatCost(2), 10, "두 번째 자리 10원(첫 구매 10초 안)")
|
||||
local prev = 0
|
||||
for s = 2, 24 do
|
||||
T.check(Economy.seatCost(s) > prev, `자리 {s} 값이 오름`)
|
||||
prev = Economy.seatCost(s)
|
||||
end
|
||||
T.check(Economy.tableCost(1, 1) > Economy.seatCost(2), "테이블은 의자보다 비쌈")
|
||||
|
||||
-- 살 수 있는 것: 건물 단계 조건
|
||||
local offers = Economy.offers(lv0, 1, 1)
|
||||
local ids = {}
|
||||
for _, o in offers do
|
||||
ids[o.id] = true
|
||||
end
|
||||
T.check(ids.Menu and ids.Price and ids.Speed and ids.Stage and ids.Staff, "처음 살 수 있는 갈래")
|
||||
T.check(not ids.Tray, "쟁반은 실내 분식집부터")
|
||||
T.check(ids.Seat and ids.Table, "의자·테이블")
|
||||
T.check(offers[1].cost <= offers[#offers].cost, "싼 순서")
|
||||
local capped = Economy.offers(lv0, 3, 6)
|
||||
for _, o in capped do
|
||||
T.check(o.kind ~= "seat" and o.kind ~= "table", "1단계 자리 최대(6)면 자리 못 삼")
|
||||
end
|
||||
|
||||
-- 시급
|
||||
T.eq(Economy.wage("Cook", s0), 12, "요리 알바 시급 12")
|
||||
T.eq(Economy.wage("Cook", p2), 18, "판매 금액 1.5배면 시급도 1.5배")
|
||||
T.eq(Economy.totalWage({ Cook = 2, Server = 1 }, s0), 39, "시급 합")
|
||||
T.eq(Economy.spawnInterval(s0, 1, false), 7.5, "홍보 알바 x0.75")
|
||||
T.eq(Economy.spawnInterval(s0, 0, true), 5, "손님 러시 x0.5")
|
||||
|
||||
-- 예전 세이브 옮기기
|
||||
local lv8, seats8, tables8, cooks8 = Economy.migrate(8)
|
||||
T.eq(lv8.Menu, 2, "예전 8개: 메뉴 2")
|
||||
T.eq(lv8.Price, 2, "양념 Lv1 = 판매 금액 1.5배")
|
||||
T.eq(lv8.Staff, 1, "알바생 기능")
|
||||
T.eq(cooks8, 1, "요리 알바 1명")
|
||||
T.eq(seats8, 3, "자리 3")
|
||||
T.eq(tables8, 3, "테이블 3")
|
||||
local lv20, seats20, tables20 = Economy.migrate(20)
|
||||
T.eq(lv20.Stage, 1, "예전 20개: 실내 분식집")
|
||||
T.eq(seats20, 8, "자리 8")
|
||||
T.eq(tables20, 6, "테이블은 2단계 최대 6")
|
||||
T.eq(Economy.migrate(0).Menu, 0, "예전 0개")
|
||||
|
||||
T.check(Economy.incomePerMinute(s0) >= 20 and Economy.incomePerMinute(s0) <= 60, "처음 1분 매출 20~60원")
|
||||
T.check(Economy.boostAmount(Economy.stats(all, 24)) > Economy.boostAmount(s0), "후반일수록 부스트가 큼")
|
||||
T.eq(Economy.shopLevel(lv0, 1), 0, "처음 가게 레벨 0")
|
||||
|
||||
T.done("Economy.spec")
|
||||
|
||||
118
bunsik-tycoon/tests/Floor.spec.luau
Normal file
118
bunsik-tycoon/tests/Floor.spec.luau
Normal file
@@ -0,0 +1,118 @@
|
||||
-- 배치·길 찾기 검사: lune run tests/Floor.spec.luau
|
||||
local Floor = require("../src/shared/Floor")
|
||||
local T = require("./check")
|
||||
|
||||
local base = Floor.default()
|
||||
T.eq(Floor.validate(base, 1), nil, "기본 배치는 문제없음")
|
||||
T.eq(#base.chairs, 1, "처음 의자 1개")
|
||||
local p1 = Floor.chairPos(base, 1)
|
||||
T.eq(p1 and p1.x, -9, "첫 의자 x")
|
||||
T.eq(p1 and p1.z, -6.5, "첫 의자는 테이블 앞(+Z) 3.5")
|
||||
|
||||
-- 밖, 겹침, 문 앞
|
||||
T.eq(select(2, Floor.move(base, 1, { kind = "table", i = 1, x = 40, z = 0 })), "bounds", "부지 밖")
|
||||
T.eq(select(2, Floor.move(base, 1, { kind = "table", i = 1, x = 0, z = 16 })), "reserved", "문 앞에는 못 놓음")
|
||||
T.eq(select(2, Floor.move(base, 1, { kind = "table", i = 1, x = 0, z = -24 })), "overlap", "조리대와 겹침")
|
||||
T.eq(select(2, Floor.move(base, 1, { kind = "table", i = 1, x = 0, z = 0, f = 2 })), "floor", "2층은 3단계부터")
|
||||
local moved, why = Floor.move(base, 1, { kind = "table", i = 1, x = 20, z = 5 })
|
||||
T.eq(why, nil, "빈 곳으로 옮기기")
|
||||
T.eq(moved and Floor.chairPos(moved, 1).x, 20, "의자도 같이 옮겨짐")
|
||||
T.eq(base.tables[1].x, -9, "원래 배치는 그대로(복사본)")
|
||||
|
||||
-- 의자 쪽 바꾸기, 같은 쪽 두 개 금지
|
||||
local two = Floor.clone(base)
|
||||
T.check(Floor.addChair(two, 1, 1) ~= nil, "의자 추가")
|
||||
T.eq(#two.chairs, 2, "의자 2")
|
||||
T.check(two.chairs[2].s ~= two.chairs[1].s, "다른 쪽에 붙음")
|
||||
T.eq(select(2, Floor.move(two, 1, { kind = "chair", i = 2, x = 1, z = 0 })), "chair", "같은 쪽 금지")
|
||||
|
||||
-- 테이블 자동 배치: 단계별 최대까지 놓을 수 있어야 함
|
||||
local full = Floor.clone(base)
|
||||
for _ = 2, 6 do
|
||||
T.check(Floor.addTable(full, 2) ~= nil, "테이블 자동 배치")
|
||||
end
|
||||
T.eq(#full.tables, 6, "테이블 6")
|
||||
T.eq(Floor.validate(full, 2), nil, "자동 배치 결과가 검사 통과")
|
||||
for _ = 1, 8 do
|
||||
T.check(Floor.addChair(full, 2) ~= nil, "의자 자동 배치")
|
||||
end
|
||||
T.eq(#full.chairs, 14, "의자 14(2단계 최대)")
|
||||
T.eq(Floor.validate(full, 2), nil, "의자 14개 배치 통과")
|
||||
|
||||
-- 길: 입구에서 의자까지
|
||||
for i = 1, #full.chairs do
|
||||
local path = Floor.pathToChair(full, 2, i)
|
||||
local last = path[#path]
|
||||
local cp = Floor.chairPos(full, i)
|
||||
T.check(last.x == cp.x and last.z == cp.z, `의자 {i}까지 길 끝`)
|
||||
T.check(Floor.pathLength(path) < 120, `의자 {i} 길 길이 적당`)
|
||||
end
|
||||
|
||||
-- 길을 막으면 거절: 조리대 앞을 테이블로 막기
|
||||
local block = Floor.clone(base)
|
||||
block.tables = { { x = -5, z = -21, f = 1 }, { x = 5, z = -21, f = 1 }, { x = 0, z = -17, f = 1 } }
|
||||
block.chairs = { { t = 1, s = 1 }, { t = 2, s = 1 }, { t = 3, s = 1 } }
|
||||
T.eq(Floor.validate(block, 1), "blocked", "조리대 앞을 테이블로 둘러싸면 거절")
|
||||
block.tables[3] = { x = 0, z = -10, f = 1 }
|
||||
T.eq(Floor.validate(block, 1), nil, "한쪽을 열면 통과")
|
||||
|
||||
-- 2층(3단계): 계단 자리 정리 후 2층에도 배치
|
||||
local stair = Floor.clone(base)
|
||||
stair.tables[1] = { x = -28, z = -2, f = 1 }
|
||||
T.eq(Floor.validate(stair, 2), nil, "2단계에서는 계단 자리에 놓아도 됨")
|
||||
T.check(Floor.validate(stair, 3) ~= nil, "3단계에서는 계단 자리와 겹침")
|
||||
local fixed = Floor.repair(stair, 3)
|
||||
T.eq(Floor.validate(fixed, 3), nil, "repair 후 통과")
|
||||
local up = Floor.clone(fixed)
|
||||
for _ = 1, 10 do
|
||||
Floor.addTable(up, 3)
|
||||
end
|
||||
local on2 = 0
|
||||
for _, t in up.tables do
|
||||
if t.f == 2 then
|
||||
on2 += 1
|
||||
end
|
||||
end
|
||||
T.check(on2 > 0, "3단계에서는 2층에도 테이블이 놓임")
|
||||
T.eq(Floor.validate(up, 3), nil, "2층 배치 통과")
|
||||
for i, t in up.tables do
|
||||
if t.f == 2 then
|
||||
for ci, c in up.chairs do
|
||||
if c.t == i then
|
||||
local path = Floor.pathToChair(up, 3, ci)
|
||||
local sawStair = false
|
||||
for _, pt in path do
|
||||
if pt.f == 2 then
|
||||
sawStair = true
|
||||
end
|
||||
end
|
||||
T.check(sawStair, "2층 의자 길은 계단을 지남")
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
-- 조리대 회전·이동
|
||||
local s2, sw = Floor.move(base, 1, { kind = "stove", i = 1, x = 20, z = -28, r = 2 })
|
||||
T.eq(sw, nil, "조리대를 옮기고 돌리기")
|
||||
T.eq(s2 and s2.stove.r, 2, "회전 저장")
|
||||
local fx, fz = Floor.stovePoint({ x = 0, z = 0, r = 1 }, { x = 0, z = 4.5 })
|
||||
T.eq(fx, 4.5, "r=1이면 앞이 +X")
|
||||
T.eq(fz, 0, "r=1 z")
|
||||
|
||||
-- 소품
|
||||
local d = Floor.clone(base)
|
||||
T.check(Floor.addDecor(d, 1, "Plant") ~= nil, "화분 놓기")
|
||||
T.check(Floor.addDecor(d, 1, "Rug") ~= nil, "러그 놓기")
|
||||
T.eq(Floor.addDecor(d, 1, "Stove"), nil, "조리대는 소품 아님")
|
||||
T.eq(Floor.validate(d, 1), nil, "소품 배치 통과")
|
||||
|
||||
-- 저장값 정리
|
||||
local cleaned =
|
||||
Floor.clean({ stove = { x = "a" }, tables = { { x = 1, z = 2, f = 9 } }, chairs = { { t = 5, s = 1 } } })
|
||||
T.eq(cleaned.stove.x, 0, "이상한 값은 기본값")
|
||||
T.eq(cleaned.tables[1].f, 1, "층은 1 또는 2")
|
||||
T.eq(#cleaned.chairs, 1, "없는 테이블 의자는 빼고 기본 의자")
|
||||
T.eq(#Floor.clean(nil).tables, 1, "nil이면 기본 배치")
|
||||
|
||||
T.done("Floor.spec")
|
||||
@@ -3,8 +3,18 @@ local Economy = require("../src/shared/Economy")
|
||||
local Shop = require("../src/shared/Shop")
|
||||
local T = require("./check")
|
||||
|
||||
local function kinds(evs, kind)
|
||||
local out = {}
|
||||
for _, e in evs do
|
||||
if e.kind == kind then
|
||||
table.insert(out, e)
|
||||
end
|
||||
end
|
||||
return out
|
||||
end
|
||||
|
||||
-- 첫 손님은 바로 오고, 걸어서 자리에 앉습니다.
|
||||
local s = Shop.new(0, 0, 100)
|
||||
local s = Shop.new({ money = 0, now = 100 })
|
||||
local ev = Shop.tick(s, 100)
|
||||
T.eq(#ev, 1, "접속하자마자 손님 1명")
|
||||
T.eq(ev[1].kind, "spawn", "spawn 이벤트")
|
||||
@@ -13,131 +23,169 @@ T.eq(Shop.nextCookMenu(s), "Tteokbokki", "걷는 중인 손님 주문도 미리
|
||||
T.eq(Shop.serve(s, 1), nil, "앉기 전에는 서빙 불가")
|
||||
|
||||
-- 자리가 1개면 두 번째 손님은 못 들어옴
|
||||
local ev2 = Shop.tick(s, 106)
|
||||
local spawned = 0
|
||||
for _, e in ev2 do
|
||||
if e.kind == "spawn" then
|
||||
spawned += 1
|
||||
end
|
||||
end
|
||||
T.eq(spawned, 0, "빈자리 없으면 손님이 지나감")
|
||||
T.eq(s.customers[1].state, "waiting", "2.5초 뒤 자리에 앉음")
|
||||
T.eq(#kinds(Shop.tick(s, 110), "spawn"), 0, "빈자리 없으면 손님이 지나감")
|
||||
T.eq(s.customers[1].state, "waiting", "자리에 앉음")
|
||||
|
||||
-- 조리 -> 서빙 -> 돈
|
||||
T.eq(Shop.cook(s), "Tteokbokki", "조리하면 떡볶이")
|
||||
T.eq(Shop.cook(s), nil, "손이 꽉 차면 더 못 만듦")
|
||||
T.eq(Shop.nextCookMenu(s), nil, "열린 주문 없음")
|
||||
local earn = Shop.serve(s, 1)
|
||||
T.eq(earn, 15, "떡볶이 15원")
|
||||
T.eq(Shop.serve(s, 1), 15, "떡볶이 15원")
|
||||
T.eq(s.money, 15, "돈 15")
|
||||
T.eq(#s.hand, 0, "접시를 내려놓음")
|
||||
T.eq(Shop.serve(s, 1), nil, "같은 손님에게 두 번 못 줌")
|
||||
T.eq(s.customers[1].state, "eating", "먹는 중")
|
||||
|
||||
-- 다 먹으면 나가고 자리가 빔
|
||||
local ev3 = Shop.tick(s, 106 + Economy.EAT + 0.1)
|
||||
local left = false
|
||||
for _, e in ev3 do
|
||||
if e.kind == "leave" then
|
||||
left = true
|
||||
end
|
||||
end
|
||||
T.check(left, "다 먹으면 나감")
|
||||
T.check(#kinds(Shop.tick(s, 110 + Economy.EAT + 0.1), "leave") == 1, "다 먹으면 나감")
|
||||
T.eq(s.customers[1], nil, "손님 목록에서 빠짐")
|
||||
|
||||
-- 구매
|
||||
local p, err = Shop.buyNext(s)
|
||||
T.eq(p and p.id, "Table2", "첫 구매는 테이블 2")
|
||||
-- 갈래 업그레이드
|
||||
local b = Shop.new({ money = 100, now = 0 })
|
||||
local lv, err = Shop.buyLevel(b, "Menu")
|
||||
T.eq(lv and lv.value, "Gimbap", "메뉴 갈래 첫 단계 = 김밥")
|
||||
T.eq(err, nil, "구매 성공")
|
||||
T.eq(s.money, 5, "돈 차감(15 - 10)")
|
||||
T.eq(s.stats.seats, 2, "테이블 2개")
|
||||
local p2, err2 = Shop.buyNext(s)
|
||||
T.eq(p2, nil, "돈이 모자라면 실패")
|
||||
T.eq(err2, "money", "실패 이유 money")
|
||||
T.eq(b.money, 60, "돈 차감")
|
||||
T.eq(#b.stats.menus, 2, "메뉴 2개")
|
||||
T.eq(select(2, Shop.buyLevel(b, "Tray")), "stage", "쟁반은 실내 분식집부터")
|
||||
T.eq(select(2, Shop.buyLevel(b, "Stage")), "money", "돈 모자람")
|
||||
b.money = 1e6
|
||||
for _ = 1, 3 do
|
||||
Shop.buyLevel(b, "Menu")
|
||||
end
|
||||
T.eq(#b.stats.menus, 3, "건물 단계가 낮으면 어묵은 못 삼")
|
||||
T.check(Shop.buyLevel(b, "Stage") ~= nil, "실내 확장")
|
||||
T.eq(b.stats.stage, 2, "2단계")
|
||||
Shop.buyLevel(b, "Menu")
|
||||
Shop.buyLevel(b, "Menu")
|
||||
T.eq(#b.stats.menus, 5, "2단계면 메뉴 5개까지")
|
||||
T.eq(select(2, Shop.buyLevel(b, "Menu")), "max", "다 삼")
|
||||
T.eq(select(2, Shop.buyLevel(b, "Nope")), "max", "없는 갈래")
|
||||
|
||||
-- 손님 오는 속도
|
||||
local sp = Shop.new({ money = 60, now = 0 })
|
||||
Shop.tick(sp, 0)
|
||||
Shop.buyLevel(sp, "Speed")
|
||||
T.eq(sp.stats.spawn, 8.5, "간격 8.5초")
|
||||
T.check(sp.nextSpawn <= 8.5, "산 직후 다음 손님 시각이 당겨짐")
|
||||
|
||||
-- 자리
|
||||
local seats = Shop.new({ money = 0, now = 0, seats = 2 })
|
||||
Shop.tick(seats, 0)
|
||||
T.eq(#kinds(Shop.tick(seats, 10), "spawn"), 1, "자리 2개면 두 번째 손님")
|
||||
Shop.setSeats(seats, 3)
|
||||
T.eq(seats.stats.seats, 3, "자리 3")
|
||||
T.check(seats.nextSpawn <= 11, "자리가 생기면 곧 손님")
|
||||
|
||||
-- 2배 수익
|
||||
local d = Shop.new(0, 0, 0)
|
||||
local d = Shop.new({ money = 0, now = 0 })
|
||||
d.moneyMult = 2
|
||||
Shop.tick(d, 0)
|
||||
Shop.tick(d, 3)
|
||||
Shop.cook(d)
|
||||
T.eq(Shop.serve(d, 1), 30, "2배 수익이면 30원")
|
||||
|
||||
-- 메뉴는 해금된 것을 돌아가며 주문
|
||||
local m = Shop.new(0, 2, 0) -- 테이블2, 김밥 해금
|
||||
Shop.tick(m, 0)
|
||||
Shop.tick(m, 6)
|
||||
T.eq(m.customers[1].menu, "Tteokbokki", "첫 손님 떡볶이")
|
||||
T.eq(m.customers[2].menu, "Gimbap", "두 번째 손님 김밥")
|
||||
|
||||
-- 다른 메뉴 접시는 다른 손님에게 못 줌
|
||||
Shop.tick(m, 9)
|
||||
T.eq(Shop.cook(m), "Tteokbokki", "먼저 온 손님 메뉴부터")
|
||||
T.eq(Shop.serve(m, 2), nil, "김밥 손님에게 떡볶이 불가")
|
||||
T.eq(Shop.serve(m, 1), 15, "떡볶이 손님에게 성공")
|
||||
|
||||
-- 요리 화면에서 메뉴 고르기: 주문이 있는 메뉴만 만들 수 있음
|
||||
local pick = Shop.new(0, 2, 0)
|
||||
local pick = Shop.new({ money = 0, now = 0, seats = 2, levels = { Menu = 1 } })
|
||||
Shop.tick(pick, 0)
|
||||
Shop.tick(pick, 6)
|
||||
Shop.tick(pick, 10)
|
||||
local counts = Shop.openCounts(pick)
|
||||
T.eq(counts.Tteokbokki, 1, "떡볶이 주문 1")
|
||||
T.eq(counts.Gimbap, 1, "김밥 주문 1")
|
||||
T.eq(Shop.cook(pick, "Sundae"), nil, "주문 없는 메뉴는 못 만듦")
|
||||
T.eq(Shop.cook(pick, "Gimbap"), "Gimbap", "나중에 온 손님 메뉴를 골라 만들 수 있음")
|
||||
T.eq(Shop.openCounts(pick).Gimbap, nil, "만든 김밥만큼 주문이 채워짐")
|
||||
T.eq(Shop.openCounts(pick).Tteokbokki, 1, "떡볶이 주문은 그대로")
|
||||
T.eq(Shop.cook(pick, "Tteokbokki"), nil, "손이 꽉 차면 못 만듦")
|
||||
|
||||
-- 알바생: 카운터에 접시를 만들어 두고, 플레이어는 집어서 나름
|
||||
local h = Shop.new(0, 8, 0)
|
||||
T.eq(h.stats.helper, true, "알바생 있음")
|
||||
-- 알바생: 잠김 → 열고 고용 → 요리 알바가 카운터에 접시
|
||||
local h = Shop.new({ money = 1000, now = 0 })
|
||||
T.eq(select(2, Shop.hire(h, "Cook")), "locked", "알바생 기능 전에는 고용 불가")
|
||||
Shop.buyLevel(h, "Staff")
|
||||
local before = h.money
|
||||
T.eq(Shop.hire(h, "Cook"), true, "요리 알바 고용")
|
||||
T.eq(h.money, before - 200, "고용비")
|
||||
Shop.hire(h, "Cook")
|
||||
T.eq(select(2, Shop.hire(h, "Cook")), "max", "요리 알바는 2명까지")
|
||||
T.eq(select(2, Shop.hire(h, "Boss")), "none", "없는 역할")
|
||||
local evs = Shop.tick(h, 0)
|
||||
local counter = 0
|
||||
for _, e in evs do
|
||||
if e.kind == "counter" then
|
||||
counter += 1
|
||||
end
|
||||
end
|
||||
T.eq(counter, 1, "알바생이 첫 주문을 바로 만듦")
|
||||
T.eq(#h.counter, 1, "카운터에 접시 1")
|
||||
T.eq(#kinds(evs, "counter"), 1, "요리 알바가 첫 주문을 바로 만듦(주문 1개)")
|
||||
T.eq(Shop.nextCookMenu(h), nil, "만들어 둔 접시가 주문을 덮음")
|
||||
T.eq(Shop.pickup(h), 1, "접시를 집음")
|
||||
T.eq(#h.counter, 0, "카운터 비움")
|
||||
Shop.tick(h, 3)
|
||||
T.check(Shop.serve(h, 1) ~= nil, "알바생 접시로 서빙")
|
||||
T.check(Shop.serve(h, 1) ~= nil, "알바 접시로 서빙")
|
||||
|
||||
-- 쟁반: 여러 접시
|
||||
local t = Shop.new(0, 11, 0)
|
||||
T.eq(t.stats.carry, 2, "쟁반이면 2개")
|
||||
T.eq(t.stats.seats, 4, "11번째까지 테이블 4")
|
||||
-- 시급: 1분마다, 모자라면 쉼
|
||||
local wage = Shop.new({ money = 0, now = 0, levels = { Staff = 1 }, staff = { Cook = 1 } })
|
||||
T.eq(#kinds(Shop.tick(wage, 1), "counter"), 1, "고용 직후 일함")
|
||||
local strike = kinds(Shop.tick(wage, Economy.WAGE_PERIOD + 0.1), "strike")
|
||||
T.eq(strike[1] and strike[1].on, true, "시급이 모자라면 쉼")
|
||||
T.eq(wage.money, 0, "빚은 지지 않음")
|
||||
Shop.tick(wage, Economy.WAGE_PERIOD + 20)
|
||||
T.eq(#wage.counter, 1, "쉬는 동안 안 만듦(처음 1개만)")
|
||||
wage.money = 100
|
||||
local paid = Shop.tick(wage, Economy.WAGE_PERIOD + 30)
|
||||
T.eq(kinds(paid, "wage")[1] and kinds(paid, "wage")[1].amount, 12, "돈이 생기면 시급 12")
|
||||
T.eq(kinds(paid, "strike")[1] and kinds(paid, "strike")[1].on, false, "다시 일함")
|
||||
T.eq(wage.money, 88, "시급 차감")
|
||||
T.eq(Shop.fire(wage, "Cook"), true, "해고")
|
||||
T.eq(Shop.fire(wage, "Cook"), false, "더 없음")
|
||||
|
||||
-- 전부 산 뒤
|
||||
local full = Shop.new(1e9, #Economy.PURCHASES, 0)
|
||||
local none, why = Shop.buyNext(full)
|
||||
T.eq(none, nil, "더 살 것 없음")
|
||||
T.eq(why, "max", "이유 max")
|
||||
-- 서빙 알바: 카운터 접시를 손님에게
|
||||
local sv = Shop.new({ money = 0, now = 0, levels = { Staff = 1 }, staff = { Cook = 1, Server = 1 } })
|
||||
local e0 = Shop.tick(sv, 0) -- 손님 + 요리 알바 접시
|
||||
T.eq(#kinds(e0, "counter"), 1, "카운터 접시")
|
||||
T.eq(#kinds(Shop.tick(sv, 1), "deliver"), 0, "손님이 앉기 전에는 안 나름")
|
||||
local e2 = Shop.tick(sv, Economy.WALK_IN + 0.1)
|
||||
T.eq(#kinds(e2, "deliver"), 1, "앉으면 서빙 알바가 가져감")
|
||||
T.eq(#sv.counter, 0, "카운터에서 빠짐")
|
||||
T.eq(Shop.serve(sv, 1), nil, "알바가 가져가는 손님은 플레이어가 못 줌")
|
||||
local e3 = Shop.tick(sv, Economy.WALK_IN + 0.1 + Economy.SERVER_TRIP + 0.1)
|
||||
local delivered = kinds(e3, "delivered")
|
||||
T.eq(delivered[1] and delivered[1].earn, 15, "서빙 알바가 놓으면 돈")
|
||||
T.eq(sv.customers[1].state, "eating", "먹는 중")
|
||||
|
||||
-- 세이브 값이 이상해도 안전
|
||||
local weird = Shop.new(5, 999, 0)
|
||||
T.eq(weird.bought, #Economy.PURCHASES, "산 개수는 최대값으로 자름")
|
||||
-- 홍보 알바·손님 러시
|
||||
local pr = Shop.new({ money = 0, now = 0, levels = { Staff = 1 }, staff = { Promoter = 1 } })
|
||||
T.eq(Shop.spawnInterval(pr), 7.5, "홍보 알바 간격 x0.75")
|
||||
Shop.addRush(pr, 30)
|
||||
T.eq(Shop.spawnInterval(pr), 3.75, "러시 x0.5")
|
||||
Shop.tick(pr, 31)
|
||||
T.eq(pr.rushLeft, 0, "러시 끝")
|
||||
|
||||
-- 옆 가게로 손님 데려가기: 먹는 중이 아닌 NPC 손님만, 늦게 온 손님부터
|
||||
local victim = Shop.new({ money = 0, now = 0, seats = 3, levels = { Menu = 1 } })
|
||||
Shop.tick(victim, 0)
|
||||
Shop.tick(victim, 10)
|
||||
Shop.tick(victim, 20)
|
||||
Shop.cook(victim) -- 1번 손님 떡볶이를 들고 있음
|
||||
local taken = Shop.takeCustomers(victim, 5)
|
||||
T.eq(#taken, 3, "3명 모두 데려감(아직 못 먹음)")
|
||||
T.eq(taken[1].id, 3, "늦게 온 손님부터")
|
||||
T.eq(next(victim.customers), nil, "손님 없음")
|
||||
-- 남은 떡볶이 접시: 다음 손님이 떡볶이를 주문
|
||||
victim.menuIndex = 1 -- 원래라면 다음은 김밥
|
||||
local nextEv = kinds(Shop.tick(victim, 30), "spawn")
|
||||
T.eq(nextEv[1] and nextEv[1].menu, "Tteokbokki", "주인 없는 접시 메뉴를 다음 손님이 주문")
|
||||
|
||||
local thief = Shop.new({ money = 0, now = 0, seats = 2 })
|
||||
local tc = Shop.addTransfer(thief, "Twigim", 7)
|
||||
T.eq(tc and tc.menu, "Tteokbokki", "우리 가게에 없는 메뉴면 우리 메뉴로")
|
||||
T.eq(tc and tc.transfer, true, "옆 가게 손님 표시")
|
||||
T.check(Shop.addTransfer(thief, "Tteokbokki", 7) ~= nil, "두 번째 자리")
|
||||
T.eq(Shop.addTransfer(thief, "Tteokbokki", 7), nil, "자리 없으면 못 옴")
|
||||
T.eq(Shop.freeSeatCount(thief), 0, "빈자리 0")
|
||||
|
||||
-- 새 메뉴를 사면 다음 손님이 1초 안에 와서 그 메뉴를 주문
|
||||
local nm = Shop.new(40, 1, 0) -- 테이블 2개, 다음 구매는 김밥 해금
|
||||
Shop.tick(nm, 0) -- 첫 손님(떡볶이)
|
||||
local bp = Shop.buyNext(nm)
|
||||
T.eq(bp and bp.id, "UnlockGimbap", "김밥 해금 구매")
|
||||
local nmEv = Shop.tick(nm, 1)
|
||||
local newOrder = nil
|
||||
for _, e in nmEv do
|
||||
if e.kind == "spawn" then
|
||||
newOrder = e.menu
|
||||
end
|
||||
end
|
||||
T.eq(newOrder, "Gimbap", "사자마자 다음 손님이 김밥 주문")
|
||||
local nm = Shop.new({ money = 40, now = 0, seats = 2 })
|
||||
Shop.tick(nm, 0)
|
||||
Shop.buyLevel(nm, "Menu")
|
||||
local newOrder = kinds(Shop.tick(nm, 1), "spawn")
|
||||
T.eq(newOrder[1] and newOrder[1].menu, "Gimbap", "사자마자 다음 손님이 김밥 주문")
|
||||
|
||||
-- 세이브 값이 이상해도 안전
|
||||
local weird = Shop.new({ money = 5, now = 0, levels = { Menu = 99 } :: any, staff = { Cook = 99, Server = -3 } })
|
||||
T.eq(#weird.stats.menus, 5, "레벨은 최대값으로 자름")
|
||||
T.eq(weird.staff.Cook, 2, "알바 수는 최대값으로 자름")
|
||||
T.eq(weird.staff.Server, 0, "음수는 0")
|
||||
|
||||
-- 플레이어 손님: 빈자리에 바로 앉고, 2배 값을 내고, 다 먹으면 나감
|
||||
local g = Shop.new(0, 1, 0) -- 테이블 2개
|
||||
local g = Shop.new({ money = 0, now = 0, seats = 2 })
|
||||
Shop.tick(g, 0) -- NPC 손님 1명(1번 자리)
|
||||
local guest = Shop.addGuest(g, 777)
|
||||
T.check(guest ~= nil, "플레이어 손님 앉음")
|
||||
@@ -145,44 +193,32 @@ T.eq(guest and guest.seat, 2, "빈 2번 자리")
|
||||
T.eq(guest and guest.state, "waiting", "걷지 않고 바로 주문")
|
||||
T.eq(Shop.addGuest(g, 777), nil, "같은 플레이어는 한 번만")
|
||||
T.eq(Shop.addGuest(g, 888), nil, "빈자리가 없으면 못 앉음")
|
||||
local spawnedWhileFull = false
|
||||
for _, e in Shop.tick(g, 6.5) do
|
||||
if e.kind == "spawn" then
|
||||
spawnedWhileFull = true
|
||||
end
|
||||
end
|
||||
T.check(not spawnedWhileFull, "플레이어 손님 자리에는 NPC가 안 옴")
|
||||
Shop.cook(g) -- 1번 손님 떡볶이
|
||||
T.eq(#kinds(Shop.tick(g, 10.5), "spawn"), 0, "플레이어 손님 자리에는 NPC가 안 옴")
|
||||
Shop.cook(g)
|
||||
T.eq(Shop.serve(g, 1), 15, "NPC 손님은 1배")
|
||||
local gid = (guest :: any).id
|
||||
T.eq(Shop.nextCookMenu(g), (guest :: any).menu, "플레이어 손님 주문도 조리대에 뜸")
|
||||
Shop.cook(g)
|
||||
T.eq(Shop.serve(g, gid), 30, "플레이어 손님은 2배")
|
||||
local guestLeave = nil
|
||||
for _, e in Shop.tick(g, 6.5 + Economy.EAT + 0.1) do
|
||||
for _, e in Shop.tick(g, 10.5 + Economy.EAT + 0.1) do
|
||||
if e.kind == "leave" and e.guest then
|
||||
guestLeave = e
|
||||
end
|
||||
end
|
||||
T.check(guestLeave ~= nil, "다 먹으면 플레이어 손님도 나감")
|
||||
T.eq(guestLeave and guestLeave.guest, 777, "나간 손님 UserId")
|
||||
T.eq(guestLeave and guestLeave.guest, 777, "다 먹으면 플레이어 손님도 나감")
|
||||
T.eq(guestLeave and guestLeave.served, true, "먹고 나감")
|
||||
T.eq(#Shop.takeCustomers(g, 5), 0, "플레이어 손님·먹는 손님은 못 데려감")
|
||||
|
||||
-- 음식을 너무 오래 못 받으면 일어남
|
||||
local w = Shop.new(0, 0, 0)
|
||||
local w = Shop.new({ money = 0, now = 0 })
|
||||
local wg = Shop.addGuest(w, 5)
|
||||
T.check(wg ~= nil, "자리 1개에 플레이어 손님")
|
||||
local hungry = nil
|
||||
for _, e in Shop.tick(w, Economy.GUEST_WAIT + 0.1) do
|
||||
if e.kind == "leave" then
|
||||
hungry = e
|
||||
end
|
||||
end
|
||||
local hungry = kinds(Shop.tick(w, Economy.GUEST_WAIT + 0.1), "leave")[1]
|
||||
T.eq(hungry and hungry.served, false, "못 먹고 나감")
|
||||
T.check(w.seatTaken[1] ~= (wg :: any).id, "자리 비움(바로 NPC 손님이 앉을 수 있음)")
|
||||
|
||||
-- 먼저 일어나면 자리만 비움
|
||||
local r = Shop.new(0, 0, 0)
|
||||
local r = Shop.new({ money = 0, now = 0 })
|
||||
local rg = Shop.addGuest(r, 9) :: any
|
||||
T.eq(Shop.removeGuest(r, rg.id) and true, true, "일어남")
|
||||
T.eq(r.seatTaken[1], nil, "자리 비움")
|
||||
|
||||
@@ -11,21 +11,23 @@ local function at(log, id)
|
||||
return math.huge
|
||||
end
|
||||
|
||||
local base = Sim.run(1, 3600)
|
||||
T.eq(#base, 20, "봇이 1시간 안에 20개 모두 삼")
|
||||
T.check(at(base, "Table2") <= 10, "첫 구매 10초 안")
|
||||
T.check(at(base, "Expand") >= 8 * 60 and at(base, "Expand") <= 12 * 60, "실내 확장 8~12분")
|
||||
local base = Sim.run(1, 7200)
|
||||
T.check(#base >= 30, "봇이 2시간 안에 30번 넘게 삼(업그레이드가 잘게 나뉨)")
|
||||
T.check(base[1].t <= 10, "첫 구매 10초 안")
|
||||
T.check(at(base, "Stage1") >= 8 * 60 and at(base, "Stage1") <= 16 * 60, "실내 확장 8~16분")
|
||||
T.check(at(base, "Stage2") >= 40 * 60 and at(base, "Stage2") <= 70 * 60, "2층 40~70분")
|
||||
T.check(at(base, "Staff1") < at(base, "Stage1"), "알바생 기능은 확장 전에 열림")
|
||||
local prev = 0
|
||||
for i, e in base do
|
||||
if i > 1 and i <= 10 then
|
||||
T.check(e.t - prev <= 100, `1단계 #{i} 구매 간격 100초 이하`)
|
||||
elseif i > 10 then
|
||||
T.check(e.t - prev <= 180, `2단계 #{i} 구매 간격 180초 이하`)
|
||||
if i > 1 and e.t < at(base, "Stage1") then
|
||||
T.check(e.t - prev <= 100, `1단계 #{i} {e.id} 구매 간격 100초 이하`)
|
||||
elseif i > 1 then
|
||||
T.check(e.t - prev <= 240, `#{i} {e.id} 구매 간격 4분 이하`)
|
||||
end
|
||||
prev = e.t
|
||||
end
|
||||
|
||||
local x2 = Sim.run(2, 3600)
|
||||
T.check(at(x2, "Expand") < at(base, "Expand") * 0.65, "2배 수익이면 확장이 훨씬 빠름")
|
||||
local x2 = Sim.run(2, 7200)
|
||||
T.check(at(x2, "Stage1") < at(base, "Stage1") * 0.65, "2배 수익이면 확장이 훨씬 빠름")
|
||||
|
||||
T.done("Sim.spec")
|
||||
|
||||
@@ -7,8 +7,8 @@ local Sim = require("./simlib")
|
||||
local mult = if table.find(process.args, "x2") then 2 else 1
|
||||
print(`수익 배율 x{mult}`)
|
||||
local prev = 0
|
||||
for i, e in Sim.run(mult, 3600) do
|
||||
for i, e in Sim.run(mult, 7200) do
|
||||
local s = math.floor(e.t + 0.5)
|
||||
print(string.format("%2d %2d:%02d (+%3ds) %-16s %5d", i, s // 60, s % 60, s - prev, e.id, e.cost))
|
||||
print(string.format("%2d %2d:%02d (+%3ds) %-12s %6d", i, s // 60, s % 60, s - prev, e.id, e.cost))
|
||||
prev = s
|
||||
end
|
||||
|
||||
@@ -1,23 +1,50 @@
|
||||
-- 경제 시뮬레이터 본체: 실제 게임 로직(src/shared/Shop)을 봇이 쉬지 않고 최적으로 플레이합니다.
|
||||
-- 경제 시뮬레이터 본체: 실제 게임 로직(src/shared/Shop)을 봇이 쉬지 않고 플레이합니다.
|
||||
-- 실행은 tools/sim.luau, 검사는 tests/Sim.spec.luau
|
||||
-- 봇 가정: 조리대 <-> 테이블 편도 WALK/2초, 알바생이 있으면 직접 조리하지 않고 나르기만 합니다.
|
||||
-- 봇 가정: 조리대 <-> 테이블 편도 WALK/2초, 요리 알바가 있으면 직접 조리하지 않고 나르기만 합니다.
|
||||
-- 조리 시간은 요리 화면을 쉬지 않고 했을 때의 시간(Recipes.expectedTime: 메뉴 고르기 + 단계 + 완성 연출)입니다.
|
||||
-- 사는 순서: 지금 살 수 있는 것(업그레이드 갈래 다음 단계, 의자, 테이블, 알바생 고용) 중 가장 싼 것부터.
|
||||
local Economy = require("../src/shared/Economy")
|
||||
local Recipes = require("../src/shared/Recipes")
|
||||
local Shop = require("../src/shared/Shop")
|
||||
|
||||
local Sim = {}
|
||||
|
||||
function Sim.run(mult: number, limit: number): { { t: number, id: string, cost: number } }
|
||||
local shop = Shop.new(0, 0, 0)
|
||||
export type Entry = { t: number, id: string, cost: number, kind: string }
|
||||
|
||||
-- 봇이 다음에 살 것(가장 싼 것)
|
||||
local function nextBuy(shop, tables: number): { kind: string, id: string, cost: number }?
|
||||
local offers = Economy.offers(shop.levels, tables, shop.stats.seats)
|
||||
local list = {}
|
||||
for _, o in offers do
|
||||
table.insert(list, { kind = o.kind, id = o.id, cost = o.cost })
|
||||
end
|
||||
if shop.stats.staffUnlocked then
|
||||
for _, r in Economy.ROLES do
|
||||
-- 서빙·홍보 알바는 실내 분식집부터 고용(봇 가정)
|
||||
local want = if r.id == "Cook" then 1 elseif shop.stats.stage >= 2 then r.max else 0
|
||||
if (shop.staff[r.id] or 0) < want then
|
||||
table.insert(list, { kind = "hire", id = r.id, cost = r.hire })
|
||||
end
|
||||
end
|
||||
end
|
||||
table.sort(list, function(a, b)
|
||||
return a.cost < b.cost
|
||||
end)
|
||||
return list[1]
|
||||
end
|
||||
|
||||
function Sim.run(mult: number, limit: number, untilStage: number?): { Entry }
|
||||
local shop = Shop.new({ money = 0, now = 0 })
|
||||
shop.moneyMult = mult
|
||||
local tables = 1
|
||||
local dt = 0.1
|
||||
local t = 0
|
||||
local at = "stove"
|
||||
local busyUntil = 0
|
||||
local pending: string? = nil -- 끝나면 할 일: "cook" | "arrive_tables" | "arrive_stove"
|
||||
local log = {}
|
||||
while t < limit and Shop.nextPurchase(shop) do
|
||||
local log: { Entry } = {}
|
||||
local goal = untilStage or 3
|
||||
while t < limit do
|
||||
Shop.tick(shop, t)
|
||||
if t >= busyUntil then
|
||||
if pending == "cook" then
|
||||
@@ -30,7 +57,8 @@ function Sim.run(mult: number, limit: number): { { t: number, id: string, cost:
|
||||
pending = nil
|
||||
if at == "stove" then
|
||||
Shop.pickup(shop)
|
||||
local canCook = not shop.stats.helper and not Shop.handFull(shop) and Shop.nextCookMenu(shop) ~= nil
|
||||
local cooks = shop.staff.Cook or 0
|
||||
local canCook = cooks == 0 and not Shop.handFull(shop) and Shop.nextCookMenu(shop) ~= nil
|
||||
if canCook then
|
||||
pending = "cook"
|
||||
local menu = Shop.nextCookMenu(shop) :: string
|
||||
@@ -51,10 +79,26 @@ function Sim.run(mult: number, limit: number): { { t: number, id: string, cost:
|
||||
end
|
||||
end
|
||||
end
|
||||
local p = Shop.nextPurchase(shop)
|
||||
if p and shop.money >= p.cost then
|
||||
Shop.buyNext(shop)
|
||||
table.insert(log, { t = t, id = p.id, cost = p.cost })
|
||||
local b = nextBuy(shop, tables)
|
||||
-- 시급 낼 돈은 남겨 둡니다.
|
||||
local reserve = Economy.totalWage(shop.staff, shop.stats)
|
||||
if b and shop.money >= b.cost + reserve then
|
||||
if b.kind == "track" then
|
||||
Shop.buyLevel(shop, b.id)
|
||||
elseif b.kind == "hire" then
|
||||
Shop.hire(shop, b.id)
|
||||
else
|
||||
Shop.spend(shop, b.cost)
|
||||
if b.kind == "table" then
|
||||
tables += 1
|
||||
end
|
||||
Shop.setSeats(shop, shop.stats.seats + 1)
|
||||
end
|
||||
local label = if b.kind == "track" then `{b.id}{shop.levels[b.id]}` else b.id
|
||||
table.insert(log, { t = t, id = label, cost = b.cost, kind = b.kind })
|
||||
if shop.stats.stage >= goal and b.id == "Stage" then
|
||||
break
|
||||
end
|
||||
end
|
||||
t += dt
|
||||
end
|
||||
|
||||
Reference in New Issue
Block a user