[💬] 컴맹인데 게임 만들고있다...

[Indie(211.117)]

extends Control

# =========================

# 상태(자원/건물/생산/용량)

# =========================

var resources: Dictionary = {

"gold": 0,

"wood": 0,

"stone": 0,

"food": 0

}

# 건물 레벨 (생산 건물 3개)

var building_level: Dictionary = {

"lumbermill": 0,

"quarry": 0,

"farm": 0

}

# 건물 업그레이드 비용 (각 비용은 자원 딕셔너리로)

var building_cost: Dictionary = {

"lumbermill": {"gold": 10, "wood": 0, "stone": 0, "food": 0},

"quarry":     {"gold": 10, "wood": 0, "stone": 0, "food": 0},

"farm":       {"gold": 10, "wood": 0, "stone": 0, "food": 0}

}

# 자원 저장 용량(최대치)

var capacity: Dictionary = {

"gold": 999999,

"wood": 200,

"stone": 200,

"food": 200

}

# 초당 생산량

var production_per_sec: Dictionary = {

"gold": 0,

"wood": 0,

"stone": 0,

"food": 0

}

# ===== 창고(용량) =====

var storage_level: int = 0

const BASE_CAPACITY: Dictionary = {

"gold": 999999,

"wood": 200,

"stone": 200,

"food": 200

}

const STORAGE_BONUS: Dictionary = {

"wood": 50,

"stone": 50,

"food": 50

}

var storage_cost: Dictionary = {"gold": 0, "wood": 50, "stone": 50, "food": 0}

# 오프라인 관련

@onready var offline_popup_label: Label = $MarginContainer/VBoxContainer/OfflinePopupLabel

# UI 라벨

@onready var gold_label: Label  = $MarginContainer/VBoxContainer/ResourceBox/GoldLabel

@onready var wood_label: Label  = $MarginContainer/VBoxContainer/ResourceBox/WoodLabel

@onready var stone_label: Label = $MarginContainer/VBoxContainer/ResourceBox/StoneLabel

@onready var food_label: Label  = $MarginContainer/VBoxContainer/ResourceBox/FoodLabel

# 건물 버튼/비용 라벨

@onready var lumber_btn: Button = $MarginContainer/VBoxContainer/BuildingBox/LumberMillBox/LumberMillButton

@onready var lumber_cost_label: Label = $MarginContainer/VBoxContainer/BuildingBox/LumberMillBox/LumberMillCostLabel

@onready var quarry_btn: Button = $MarginContainer/VBoxContainer/BuildingBox/QuarryBox/QuarryButton

@onready var quarry_cost_label: Label = $MarginContainer/VBoxContainer/BuildingBox/QuarryBox/QuarryCostLabel

@onready var farm_btn: Button = $MarginContainer/VBoxContainer/BuildingBox/FarmBox/FarmButton

@onready var farm_cost_label: Label = $MarginContainer/VBoxContainer/BuildingBox/FarmBox/FarmCostLabel

@onready var storage_btn: Button = $MarginContainer/VBoxContainer/BuildingBox/StorageBox/StorageButton

@onready var storage_cost_label: Label = $MarginContainer/VBoxContainer/BuildingBox/StorageBox/StorageCostLabel

# 저장

const SAVE_PATH := "user://save.json"

const SAVE_VERSION := 1

func _ready() -> void:

load_game()

recalc_capacity()

recalc_production()

update_ui()

# =========================

# UI 갱신

# =========================

func update_ui() -> void:

# 자원 라벨

gold_label.text  = "Gold:  %d / %d" % [int(resources["gold"]),  int(capacity["gold"])]

wood_label.text  = "Wood:  %d / %d" % [int(resources["wood"]),  int(capacity["wood"])]

stone_label.text = "Stone: %d / %d" % [int(resources["stone"]), int(capacity["stone"])]

food_label.text  = "Food:  %d / %d" % [int(resources["food"]),  int(capacity["food"])]

# 버튼 텍스트(레벨)

lumber_btn.text = "LumberMill Lv.%d" % int(building_level["lumbermill"])

quarry_btn.text = "Quarry Lv.%d" % int(building_level["quarry"])

farm_btn.text   = "Farm Lv.%d" % int(building_level["farm"])

# 비용 표시

lumber_cost_label.text = "Cost: " + format_cost(building_cost["lumbermill"])

quarry_cost_label.text = "Cost: " + format_cost(building_cost["quarry"])

farm_cost_label.text   = "Cost: " + format_cost(building_cost["farm"])

# 구매 가능/불가

lumber_btn.disabled = not can_afford(building_cost["lumbermill"])

quarry_btn.disabled = not can_afford(building_cost["quarry"])

farm_btn.disabled   = not can_afford(building_cost["farm"])

# ---- 창고 UI ----

if is_instance_valid(storage_btn):

storage_btn.text = "Storage Lv.%d" % storage_level

storage_btn.disabled = not can_afford(storage_cost)

if is_instance_valid(storage_cost_label):

storage_cost_label.text = "Cost: " + format_cost(storage_cost)

func format_cost(cost: Dictionary) -> String:

var parts: Array[String] = []

for k in ["gold","wood","stone","food"]:

var v := int(cost.get(k, 0))

if v > 0:

parts.append("%s %d" % [k.capitalize(), v])

if parts.is_empty():

return "Free"

return ", ".join(parts)

# =========================

# 생산/용량/클램프

# =========================

func clamp_resource(key: String) -> void:

if not resources.has(key): return

if not capacity.has(key): return

resources[key] = clampi(int(resources[key]), 0, int(capacity[key]))

func add_resource(key: String, amount: int) -> void:

if not resources.has(key): return

resources[key] = int(resources[key]) + int(amount)

clamp_resource(key)

func recalc_production() -> void:

# 생산 공식(일단 단순):

# - LumberMill 레벨당 wood +1/s

# - Quarry 레벨당 stone +1/s

# - Farm 레벨당 food +1/s

production_per_sec["wood"]  = int(building_level["lumbermill"]) * 1

production_per_sec["stone"] = int(building_level["quarry"]) * 1

production_per_sec["food"]  = int(building_level["farm"]) * 1

# gold는 지금은 생산 없음(원하면 나중에 "세금" 같은 건물로 추가)

production_per_sec["gold"] = 0

func recalc_capacity() -> void:

for k in BASE_CAPACITY.keys():

if k == "gold":

capacity[k] = int(BASE_CAPACITY[k])

else:

capacity[k] = int(BASE_CAPACITY[k]) + storage_level * int(STORAGE_BONUS[k])

clamp_resource(String(k))

# =========================

# 타이머: 초당 생산

# =========================

func _on_timer_timeout() -> void:

for k in production_per_sec.keys():

add_resource(String(k), int(production_per_sec[k]))

update_ui()

# 원하면 주기 저장:

# save_game()

# =========================

# 건물 업그레이드(버튼 3개)

# =========================

func _on_lumbermill_pressed() -> void:

try_upgrade_building("lumbermill")

func _on_quarry_pressed() -> void:

try_upgrade_building("quarry")

func _on_farm_pressed() -> void:

try_upgrade_building("farm")

func try_upgrade_building(id: String) -> void:

var cost: Dictionary = building_cost.get(id, {})

if not can_afford(cost):

return

pay_cost(cost)

building_level[id] = int(building_level[id]) + 1

# 비용 증가 규칙(예시): gold는 1.6배+5, 해당 자원도 조금씩 요구

grow_building_cost(id)

recalc_production()

update_ui()

save_game()

func can_afford(cost: Dictionary) -> bool:

for k in cost.keys():

var need := int(cost.get(k, 0))

if need <= 0:

continue

if int(resources.get(k, 0)) < need:

return false

return true

func pay_cost(cost: Dictionary) -> void:

for k in cost.keys():

var need := int(cost.get(k, 0))

if need <= 0:

continue

resources[k] = int(resources.get(k, 0)) - need

clamp_resource(String(k))

func grow_building_cost(id: String) -> void:

var lv := int(building_level[id])

var c: Dictionary = building_cost[id]

# gold 기본 증가

c["gold"] = int(max(1, int(c.get("gold", 10)) * 1.6)) + 5

# 해당 건물과 관련 자원도 조금 요구(예시)

if id == "lumbermill":

c["wood"] = int(lv * 3)

elif id == "quarry":

c["stone"] = int(lv * 3)

elif id == "farm":

c["food"] = int(lv * 3)

# 딕셔너리 반영

building_cost[id] = c

# =========================

# 저장/불러오기 + 오프라인

# =========================

func make_save_data() -> Dictionary:

return {

"v": SAVE_VERSION,

"resources": resources,

"building_level": building_level,

"building_cost": building_cost,

"storage_level": storage_level,

"storage_cost": storage_cost,

"last_play_time": int(Time.get_unix_time_from_system())

}

func apply_save_data(data: Dictionary) -> void:

# resources

var saved_resources: Dictionary = data.get("resources", {})

if typeof(saved_resources) == TYPE_DICTIONARY:

for key in resources.keys():

resources[key] = int(saved_resources.get(key, resources[key]))

clamp_resource(String(key))

# building_level

var saved_lv: Dictionary = data.get("building_level", {})

if typeof(saved_lv) == TYPE_DICTIONARY:

for key in building_level.keys():

building_level[key] = int(saved_lv.get(key, building_level[key]))

# building_cost

var saved_cost: Dictionary = data.get("building_cost", {})

if typeof(saved_cost) == TYPE_DICTIONARY:

for key in building_cost.keys():

var saved_entry = saved_cost.get(key, {})

if typeof(saved_entry) == TYPE_DICTIONARY:

building_cost[key] = saved_entry.duplicate(true)

storage_level = int(data.get("storage_level", storage_level))

var saved_sc: Dictionary = data.get("storage_cost", {})

if typeof(saved_sc) == TYPE_DICTIONARY:

for k in storage_cost.keys():

storage_cost[k] = int(saved_sc.get(k, storage_cost[k]))

recalc_capacity()

recalc_production()

func save_game() -> void:

var data := make_save_data()

var file := FileAccess.open(SAVE_PATH, FileAccess.WRITE)

if file == null:

push_error("Save failed: cannot open file")

return

file.store_string(JSON.stringify(data))

file.close()

func load_game() -> void:

if not FileAccess.file_exists(SAVE_PATH):

return

var file := FileAccess.open(SAVE_PATH, FileAccess.READ)

if file == null:

push_error("Load failed: cannot open file")

return

var text := file.get_as_text()

file.close()

var parsed: Variant = JSON.parse_string(text)

if typeof(parsed) != TYPE_DICTIONARY:

push_error("Load failed: invalid json")

return

var data: Dictionary = parsed as Dictionary

apply_save_data(data)

apply_offline_earnings(data)

func apply_offline_earnings(data: Dictionary) -> void:

var last_time: int = int(data.get("last_play_time", 0))

if last_time <= 0:

return

var now: int = int(Time.get_unix_time_from_system())

var offline_seconds: int = maxi(0, now - last_time)

# 기본 상한(지금은 8시간)

var max_seconds: int = 8 * 60 * 60

offline_seconds = mini(offline_seconds, max_seconds)

if offline_seconds <= 0:

return

# 오프라인 동안 생산 적용(wood/stone/food)

var earned: Dictionary = {"wood":0,"stone":0,"food":0}

for k in ["wood","stone","food"]:

var gain := offline_seconds * int(production_per_sec[k])

if gain > 0:

earned[k] = gain

add_resource(k, gain)

show_offline_popup_multi(offline_seconds, earned)

func show_offline_popup_multi(seconds: int, earned: Dictionary) -> void:

if offline_popup_label == null:

return

var parts: Array[String] = []

for k in ["wood","stone","food"]:

var v := int(earned.get(k, 0))

if v > 0:

parts.append("+" + str(v) + " " + k.capitalize())

if parts.is_empty():

return

offline_popup_label.text = "오프라인 " + format_duration(seconds) + " 동안 " + ", ".join(parts)

offline_popup_label.visible = true

offline_popup_label.modulate.a = 1.0

await get_tree().create_timer(1.2).timeout

var t := create_tween()

t.tween_property(offline_popup_label, "modulate:a", 0.0, 0.6)

await t.finished

offline_popup_label.visible = false

offline_popup_label.modulate.a = 1.0

func format_duration(total_seconds: int) -> String:

var s: int = maxi(0, total_seconds)

var h: int = s / 3600

var m: int = (s % 3600) / 60

var sec: int = s % 60

if h > 0:

return str(h) + "시간 " + str(m) + "분"

elif m > 0:

return str(m) + "분 " + str(sec) + "초"

else:

return str(sec) + "초"

func _on_storage_button_pressed() -> void:

try_upgrade_storage()

func try_upgrade_storage() -> void:

if not can_afford(storage_cost):

return

pay_cost(storage_cost)

storage_level += 1

# 비용 증가 규칙(예시): wood/stone 1.5배 + 20, gold도 조금씩 요구

grow_storage_cost()

recalc_capacity()

update_ui()

save_game()

func grow_storage_cost() -> void:

storage_cost["wood"]  = int(max(1, int(storage_cost.get("wood", 50)) * 1.5)) + 20

storage_cost["stone"] = int(max(1, int(storage_cost.get("stone", 50)) * 1.5)) + 20

storage_cost["gold"]  = int(max(0, int(storage_cost.get("gold", 0)) * 1.4)) + (storage_level * 5)

[글쓴 Indie(211.117)]

잘 하고 있는지도 모르겠는데 요즘 겜들은 너무 과금유도만 드럽게 심한 것 같아서 내 로망이 가득한 게임 만들어보려고 한다

[익명(pianist8697)]

var 말고 son 해라

[글쓴 Indie(211.117)]

차이가 뭐임?

[Indie 1(14.138)]

깃헙써