forked from retoor/devplacepy
626 lines
22 KiB
Python
626 lines
22 KiB
Python
# retoor <retoor@molodetz.nl>
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
from datetime import datetime, timedelta
|
|
|
|
from devplacepy.utils import generate_uid
|
|
|
|
from .. import economy
|
|
from .common import (
|
|
GameError,
|
|
PERK_COLUMN,
|
|
conditional_update_farm,
|
|
credit_farm,
|
|
_iso,
|
|
_iso_week,
|
|
_lvl,
|
|
_now,
|
|
_parse,
|
|
_parse_date,
|
|
_plots,
|
|
_quests,
|
|
_steals,
|
|
_today,
|
|
_update_farm,
|
|
steal_cooldown_remaining,
|
|
)
|
|
from .era import active_era_name
|
|
from .farm import _create_plot, _plot_at, ensure_farm, get_farm, get_plots
|
|
from .infrastructure import owns_infrastructure, roll_canary
|
|
from .market import market_factor_for, record_harvest_tick
|
|
from .mastery import MASTERY_COLUMN
|
|
from .quests import advance_quests, ensure_quests
|
|
from .serialize import _daily_available, _plot_state, _watered_by
|
|
|
|
|
|
def plant(user: dict, slot: int, crop_key: str) -> dict:
|
|
farm = ensure_farm(user["uid"])
|
|
crop = economy.crop_for(crop_key)
|
|
if not crop:
|
|
raise GameError("Unknown crop type.")
|
|
progress = economy.level_progress(int(farm.get("xp", 0)))
|
|
if crop.min_level > progress["level"]:
|
|
raise GameError(f"{crop.name} unlocks at level {crop.min_level}.")
|
|
if crop.min_mastery > _lvl(farm, "mastery_points_earned_total"):
|
|
raise GameError(f"{crop.name} unlocks after reaching Mastery.")
|
|
if crop.era_key and crop.era_key != active_era_name():
|
|
raise GameError(f"{crop.name} is not available right now.")
|
|
plot = _plot_at(farm["uid"], slot)
|
|
if not plot:
|
|
raise GameError("That plot does not exist.")
|
|
if plot.get("crop_key"):
|
|
raise GameError("That plot is already in use.")
|
|
coins = int(farm.get("coins", 0))
|
|
cost = economy.effective_plant_cost(crop, _lvl(farm, "perk_discount"))
|
|
if coins < cost:
|
|
raise GameError("Not enough coins to plant that.")
|
|
now = _now()
|
|
ci_tier = int(farm.get("ci_tier", 1))
|
|
grow = economy.grow_seconds_for(
|
|
crop,
|
|
ci_tier,
|
|
_lvl(farm, "perk_growth"),
|
|
_lvl(farm, "legacy_speed"),
|
|
owns_infrastructure(farm, "registry"),
|
|
)
|
|
ready_at = now + timedelta(seconds=grow)
|
|
_plots().update(
|
|
{
|
|
"uid": plot["uid"],
|
|
"crop_key": crop.key,
|
|
"planted_at": _iso(now),
|
|
"ready_at": _iso(ready_at),
|
|
"watered_by": "[]",
|
|
"updated_at": _iso(now),
|
|
},
|
|
["uid"],
|
|
)
|
|
_update_farm(farm["uid"], {"coins": coins - cost})
|
|
advance_quests(user["uid"], "plant", 1)
|
|
return {"slot": slot, "crop": crop.key, "spent": cost}
|
|
|
|
|
|
def _harvest_crop(farm: dict, crop, plot_uid: str, planted_at: str, now) -> dict:
|
|
prestige = _lvl(farm, "prestige")
|
|
golden = economy.is_golden(plot_uid, planted_at)
|
|
market_factor = market_factor_for(crop.key)
|
|
underdog = bool(farm.get("underdog_boost_until")) and now < (
|
|
_parse(farm.get("underdog_boost_until") or "") or now
|
|
)
|
|
coins_gain = economy.effective_reward_coins(
|
|
crop,
|
|
_lvl(farm, "perk_yield"),
|
|
prestige,
|
|
_lvl(farm, "legacy_multiplier"),
|
|
market_factor,
|
|
underdog,
|
|
)
|
|
if golden:
|
|
coins_gain *= economy.GOLDEN_MULTIPLIER
|
|
contract_boost_until = _parse(farm.get("contract_boost_until") or "")
|
|
if contract_boost_until and now < contract_boost_until:
|
|
coins_gain = round(coins_gain * economy.WEEKLY_CONTRACT_BOOST_MULTIPLIER)
|
|
if owns_infrastructure(farm, "canary"):
|
|
plant_cost = economy.effective_plant_cost(crop, _lvl(farm, "perk_discount"))
|
|
coins_gain = roll_canary(coins_gain, plant_cost)
|
|
xp_gain = economy.effective_reward_xp(crop, _lvl(farm, "perk_xp"))
|
|
record_harvest_tick(crop.key, now)
|
|
return {"coins": coins_gain, "xp": xp_gain, "golden": golden}
|
|
|
|
|
|
def harvest(user: dict, slot: int) -> dict:
|
|
farm = ensure_farm(user["uid"])
|
|
plot = _plot_at(farm["uid"], slot)
|
|
if not plot or not plot.get("crop_key"):
|
|
raise GameError("That plot is empty.")
|
|
now = _now()
|
|
if _plot_state(plot, now) != "ready":
|
|
raise GameError("That build is still running.")
|
|
crop = economy.crop_for(plot.get("crop_key", ""))
|
|
if not crop:
|
|
raise GameError("Unknown crop type.")
|
|
planted_at = plot.get("planted_at", "")
|
|
_plots().update(
|
|
{
|
|
"uid": plot["uid"],
|
|
"crop_key": "",
|
|
"planted_at": "",
|
|
"ready_at": "",
|
|
"watered_by": "[]",
|
|
"updated_at": _iso(now),
|
|
},
|
|
["uid"],
|
|
)
|
|
result = _harvest_crop(farm, crop, plot.get("uid", ""), planted_at, now)
|
|
coins_gain, xp_gain, golden = result["coins"], result["xp"], result["golden"]
|
|
extra = {}
|
|
if crop.key == "kernel" and _lvl(farm, "last_kernel_harvest_prestige") != _lvl(farm, "prestige"):
|
|
prestiged_at = _parse(farm.get("prestiged_at") or "")
|
|
if prestiged_at:
|
|
extra["time_to_kernel_seconds"] = max(0, int((now - prestiged_at).total_seconds()))
|
|
extra["last_kernel_harvest_prestige"] = _lvl(farm, "prestige")
|
|
farm = credit_farm(
|
|
farm,
|
|
coins=coins_gain,
|
|
xp=xp_gain,
|
|
harvests=1,
|
|
era_active=bool(active_era_name()),
|
|
extra=extra or None,
|
|
)
|
|
advance_quests(user["uid"], "harvest", 1)
|
|
advance_quests(user["uid"], "earn", coins_gain)
|
|
if _lvl(farm, MASTERY_COLUMN["autoreplant"]):
|
|
_try_autoreplant(farm, slot, crop, now)
|
|
return {
|
|
"slot": slot,
|
|
"crop": crop.key,
|
|
"coins": coins_gain,
|
|
"xp": xp_gain,
|
|
"golden": golden,
|
|
}
|
|
|
|
|
|
def _try_autoreplant(farm: dict, slot: int, crop, now) -> None:
|
|
plot = _plot_at(farm["uid"], slot)
|
|
if not plot or plot.get("crop_key"):
|
|
return
|
|
cost = economy.effective_plant_cost(crop, _lvl(farm, "perk_discount"))
|
|
if int(farm.get("coins", 0)) < cost:
|
|
return
|
|
grow = economy.grow_seconds_for(
|
|
crop,
|
|
int(farm.get("ci_tier", 1)),
|
|
_lvl(farm, "perk_growth"),
|
|
_lvl(farm, "legacy_speed"),
|
|
owns_infrastructure(farm, "registry"),
|
|
)
|
|
ready_at = now + timedelta(seconds=grow)
|
|
_plots().update(
|
|
{
|
|
"uid": plot["uid"],
|
|
"crop_key": crop.key,
|
|
"planted_at": _iso(now),
|
|
"ready_at": _iso(ready_at),
|
|
"watered_by": "[]",
|
|
"updated_at": _iso(now),
|
|
},
|
|
["uid"],
|
|
)
|
|
_update_farm(farm["uid"], {"coins": int(farm.get("coins", 0)) - cost})
|
|
|
|
|
|
def water(visitor: dict, owner: dict, slot: int) -> dict:
|
|
if visitor["uid"] == owner["uid"]:
|
|
raise GameError("You cannot water your own build.")
|
|
farm = ensure_farm(owner["uid"])
|
|
plot = _plot_at(farm["uid"], slot)
|
|
if not plot or not plot.get("crop_key"):
|
|
raise GameError("That plot is empty.")
|
|
now = _now()
|
|
if _plot_state(plot, now) != "growing":
|
|
raise GameError("That build is not running.")
|
|
watered = _watered_by(plot)
|
|
if visitor["uid"] in watered:
|
|
raise GameError("You already watered this build.")
|
|
if len(watered) >= economy.MAX_WATERS_PER_PLOT:
|
|
raise GameError("This build has been watered enough.")
|
|
crop = economy.crop_for(plot.get("crop_key", ""))
|
|
ready_at = _parse(plot.get("ready_at", "")) or now
|
|
bonus = economy.water_bonus_seconds(
|
|
crop, int(farm.get("ci_tier", 1)), _lvl(farm, "perk_growth"), _lvl(farm, "legacy_speed")
|
|
)
|
|
if owns_infrastructure(farm, "registry") and crop.key in economy.REGISTRY_BOOST_CROPS:
|
|
bonus = round(bonus * economy.REGISTRY_BOOST_FACTOR)
|
|
new_ready = max(now, ready_at - timedelta(seconds=bonus))
|
|
watered.append(visitor["uid"])
|
|
_plots().update(
|
|
{
|
|
"uid": plot["uid"],
|
|
"ready_at": _iso(new_ready),
|
|
"watered_by": json.dumps(watered),
|
|
"updated_at": _iso(now),
|
|
},
|
|
["uid"],
|
|
)
|
|
visitor_farm = ensure_farm(visitor["uid"])
|
|
new_xp = int(visitor_farm.get("xp", 0)) + economy.WATER_REWARD_XP
|
|
_update_farm(
|
|
visitor_farm["uid"],
|
|
{
|
|
"coins": int(visitor_farm.get("coins", 0)) + economy.WATER_REWARD_COINS,
|
|
"xp": new_xp,
|
|
"level": economy.level_for_xp(new_xp),
|
|
},
|
|
)
|
|
advance_quests(visitor["uid"], "water", 1)
|
|
return {
|
|
"slot": slot,
|
|
"bonus_seconds": bonus,
|
|
"reward_coins": economy.WATER_REWARD_COINS,
|
|
"reward_xp": economy.WATER_REWARD_XP,
|
|
}
|
|
|
|
|
|
def steal(thief: dict, owner: dict, slot: int) -> dict:
|
|
if thief["uid"] == owner["uid"]:
|
|
raise GameError("You cannot steal from your own farm.")
|
|
farm = ensure_farm(owner["uid"])
|
|
plot = _plot_at(farm["uid"], slot)
|
|
if not plot or not plot.get("crop_key"):
|
|
raise GameError("That plot is empty.")
|
|
now = _now()
|
|
if _plot_state(plot, now) != "ready":
|
|
raise GameError("That build is not ready.")
|
|
crop = economy.crop_for(plot.get("crop_key", ""))
|
|
if not crop:
|
|
raise GameError("Unknown crop type.")
|
|
if crop.steal_immune:
|
|
raise GameError("That build cannot be raided.")
|
|
defense_level = _lvl(farm, "legacy_defense")
|
|
building_level = _lvl(farm, "defense_level")
|
|
building_tier = economy.defense_tier(building_level)
|
|
floor = building_tier.steal_fraction_floor
|
|
if owns_infrastructure(farm, "observability"):
|
|
floor = max(floor, economy.OBSERVABILITY_STEAL_FLOOR)
|
|
grace = economy.effective_steal_grace(defense_level, building_tier.grace_bonus)
|
|
ready_at = _parse(plot.get("ready_at", "")) or now
|
|
if now < ready_at + timedelta(seconds=grace):
|
|
raise GameError("That harvest is still protected.")
|
|
cooldown = steal_cooldown_remaining(thief["uid"], owner["uid"], now)
|
|
if cooldown > 0:
|
|
minutes = max(1, (cooldown + 59) // 60)
|
|
raise GameError(
|
|
f"You can only raid {owner.get('username', 'this farmer')} "
|
|
f"once an hour. Try again in {minutes} min."
|
|
)
|
|
_plots().update(
|
|
{
|
|
"uid": plot["uid"],
|
|
"crop_key": "",
|
|
"planted_at": "",
|
|
"ready_at": "",
|
|
"watered_by": "[]",
|
|
"updated_at": _iso(now),
|
|
},
|
|
["uid"],
|
|
)
|
|
market_factor = market_factor_for(crop.key)
|
|
coins_gain = economy.steal_reward_coins(
|
|
crop,
|
|
_lvl(farm, "perk_yield"),
|
|
_lvl(farm, "prestige"),
|
|
_lvl(farm, "legacy_multiplier"),
|
|
defense_level,
|
|
market_factor,
|
|
floor,
|
|
)
|
|
thief_farm = ensure_farm(thief["uid"])
|
|
underdog_extra = {}
|
|
if int(farm.get("coins", 0)) > int(thief_farm.get("coins", 0)) * economy.UNDERDOG_COIN_RATIO:
|
|
underdog_extra["underdog_boost_until"] = _iso(
|
|
now + timedelta(hours=economy.UNDERDOG_DURATION_HOURS)
|
|
)
|
|
credit_farm(
|
|
thief_farm,
|
|
coins=coins_gain,
|
|
era_active=bool(active_era_name()),
|
|
extra=underdog_extra or None,
|
|
)
|
|
_steals().insert(
|
|
{
|
|
"uid": generate_uid(),
|
|
"thief_uid": thief["uid"],
|
|
"owner_uid": owner["uid"],
|
|
"slot_index": slot,
|
|
"crop_key": crop.key,
|
|
"coins": coins_gain,
|
|
"stolen_at": _iso(now),
|
|
"created_at": _iso(now),
|
|
}
|
|
)
|
|
return {
|
|
"slot": slot,
|
|
"crop": crop.key,
|
|
"coins": coins_gain,
|
|
"owner_uid": owner["uid"],
|
|
"underdog_triggered": bool(underdog_extra),
|
|
}
|
|
|
|
|
|
def _auto_harvest(farm: dict, owner_uid: str, now: datetime) -> dict:
|
|
coins_gain = 0
|
|
xp_gain = 0
|
|
harvested = 0
|
|
replant_slots = []
|
|
extra = {}
|
|
for plot in get_plots(farm["uid"]):
|
|
if _plot_state(plot, now) != "ready":
|
|
continue
|
|
crop = economy.crop_for(plot.get("crop_key", ""))
|
|
if not crop:
|
|
continue
|
|
result = _harvest_crop(farm, crop, plot.get("uid", ""), plot.get("planted_at", ""), now)
|
|
_plots().update(
|
|
{
|
|
"uid": plot["uid"],
|
|
"crop_key": "",
|
|
"planted_at": "",
|
|
"ready_at": "",
|
|
"watered_by": "[]",
|
|
"updated_at": _iso(now),
|
|
},
|
|
["uid"],
|
|
)
|
|
coins_gain += result["coins"]
|
|
xp_gain += result["xp"]
|
|
harvested += 1
|
|
replant_slots.append((int(plot.get("slot_index", 0)), crop))
|
|
if crop.key == "kernel" and _lvl(farm, "last_kernel_harvest_prestige") != _lvl(
|
|
farm, "prestige"
|
|
):
|
|
prestiged_at = _parse(farm.get("prestiged_at") or "")
|
|
if prestiged_at:
|
|
extra["time_to_kernel_seconds"] = max(0, int((now - prestiged_at).total_seconds()))
|
|
extra["last_kernel_harvest_prestige"] = _lvl(farm, "prestige")
|
|
if not harvested:
|
|
return farm
|
|
farm = credit_farm(
|
|
farm,
|
|
coins=coins_gain,
|
|
xp=xp_gain,
|
|
harvests=harvested,
|
|
era_active=bool(active_era_name()),
|
|
extra=extra or None,
|
|
)
|
|
advance_quests(owner_uid, "harvest", harvested)
|
|
advance_quests(owner_uid, "earn", coins_gain)
|
|
if _lvl(farm, MASTERY_COLUMN["autoreplant"]):
|
|
for slot_index, crop in replant_slots:
|
|
_try_autoreplant(farm, slot_index, crop, now)
|
|
return get_farm(owner_uid) or farm
|
|
|
|
|
|
def claim_quest(user: dict, kind: str, scope: str = "daily") -> dict:
|
|
from .quests import ensure_weekly_contract
|
|
|
|
farm = ensure_farm(user["uid"])
|
|
now = _now()
|
|
if scope == "weekly":
|
|
day = _iso_week(now)
|
|
ensure_weekly_contract(farm, day)
|
|
else:
|
|
day = _today()
|
|
ensure_quests(farm, day)
|
|
row = _quests().find_one(farm_uid=farm["uid"], day=day, kind=kind, scope=scope)
|
|
if not row:
|
|
raise GameError("No such quest today.")
|
|
if row.get("claimed"):
|
|
raise GameError("Quest already claimed.")
|
|
goal = int(row.get("goal") or 0)
|
|
if int(row.get("progress") or 0) < goal:
|
|
raise GameError("Quest not complete yet.")
|
|
reward_coins = int(row.get("reward_coins") or 0)
|
|
reward_xp = int(row.get("reward_xp") or 0)
|
|
reward_stars = int(row.get("reward_stars") or 0)
|
|
_quests().update(
|
|
{"uid": row["uid"], "claimed": 1, "updated_at": _iso(now)}, ["uid"]
|
|
)
|
|
extra = {"stars": _lvl(farm, "stars") + reward_stars} if reward_stars else None
|
|
if scope == "weekly":
|
|
extra = extra or {}
|
|
extra["contract_boost_until"] = _iso(
|
|
now + timedelta(hours=economy.WEEKLY_CONTRACT_BOOST_HOURS)
|
|
)
|
|
credit_farm(farm, coins=reward_coins, xp=reward_xp, extra=extra)
|
|
return {
|
|
"kind": kind,
|
|
"reward_coins": reward_coins,
|
|
"reward_xp": reward_xp,
|
|
"reward_stars": reward_stars,
|
|
}
|
|
|
|
|
|
def claim_daily(user: dict) -> dict:
|
|
farm = ensure_farm(user["uid"])
|
|
now = _now()
|
|
if not _daily_available(farm, now):
|
|
raise GameError("Daily bonus already claimed today.")
|
|
last = _parse_date(farm.get("last_daily_at") or "")
|
|
streak = _lvl(farm, "streak") + 1 if last == now.date() - timedelta(days=1) else 1
|
|
reward = economy.daily_reward(streak)
|
|
credit_farm(
|
|
farm,
|
|
coins=reward,
|
|
era_active=bool(active_era_name()),
|
|
extra={"streak": streak, "last_daily_at": _iso(now)},
|
|
)
|
|
return {"reward": reward, "streak": streak}
|
|
|
|
|
|
def upgrade_perk(user: dict, perk_key: str) -> dict:
|
|
perk = economy.perk_for(perk_key)
|
|
if not perk:
|
|
raise GameError("Unknown perk.")
|
|
farm = ensure_farm(user["uid"])
|
|
column = PERK_COLUMN[perk.key]
|
|
level = _lvl(farm, column)
|
|
if level >= perk.max_level:
|
|
raise GameError("That perk is maxed out.")
|
|
cost = economy.perk_cost(perk, level)
|
|
rows = conditional_update_farm(
|
|
farm["uid"],
|
|
set_clause=f"coins = coins - :cost, {column} = :new_level",
|
|
where_clause=f"COALESCE({column}, 0) = :current_level AND coins >= :cost",
|
|
params={"cost": cost, "new_level": level + 1, "current_level": level},
|
|
)
|
|
if rows == 0:
|
|
farm = get_farm(user["uid"])
|
|
if _lvl(farm, column) != level:
|
|
raise GameError("That perk already changed - refresh and try again.")
|
|
raise GameError("Not enough coins for that upgrade.")
|
|
return {"perk": perk.key, "level": level + 1, "spent": cost}
|
|
|
|
|
|
def upgrade_legacy(user: dict, key: str) -> dict:
|
|
upgrade = economy.legacy_for(key)
|
|
if not upgrade:
|
|
raise GameError("Unknown legacy upgrade.")
|
|
farm = ensure_farm(user["uid"])
|
|
column = f"legacy_{upgrade.key}"
|
|
level = _lvl(farm, column)
|
|
if level >= upgrade.max_level:
|
|
raise GameError("That legacy upgrade is maxed out.")
|
|
cost = economy.legacy_cost(upgrade, level)
|
|
rows = conditional_update_farm(
|
|
farm["uid"],
|
|
set_clause=f"stars = COALESCE(stars, 0) - :cost, {column} = :new_level",
|
|
where_clause=f"COALESCE({column}, 0) = :current_level AND COALESCE(stars, 0) >= :cost",
|
|
params={"cost": cost, "new_level": level + 1, "current_level": level},
|
|
)
|
|
if rows == 0:
|
|
farm = get_farm(user["uid"])
|
|
if _lvl(farm, column) != level:
|
|
raise GameError("That legacy upgrade already changed - refresh and try again.")
|
|
raise GameError("Not enough stars for that legacy upgrade.")
|
|
return {"key": upgrade.key, "level": level + 1, "spent": cost}
|
|
|
|
|
|
def prestige(user: dict) -> dict:
|
|
from .treasury import credit_treasury
|
|
|
|
farm = ensure_farm(user["uid"])
|
|
level = economy.level_for_xp(int(farm.get("xp", 0)))
|
|
if level < economy.PRESTIGE_MIN_LEVEL:
|
|
raise GameError(
|
|
f"Reach level {economy.PRESTIGE_MIN_LEVEL} to refactor (prestige)."
|
|
)
|
|
old_prestige = _lvl(farm, "prestige")
|
|
new_prestige = old_prestige + 1
|
|
coins_now = int(farm.get("coins", 0))
|
|
fee = economy.refactor_cost(old_prestige, coins_now)
|
|
if coins_now < fee:
|
|
raise GameError(
|
|
f"Refactoring costs {fee} coins right now - keep farming to afford it."
|
|
)
|
|
carried = economy.refactor_carryover(coins_now, fee, _lvl(farm, "legacy_carryover"))
|
|
stars_award = economy.stars_for_refactor(level, old_prestige)
|
|
mastery_award = economy.mastery_points_awarded(old_prestige, new_prestige)
|
|
base_plots = economy.prestige_base_plots(_lvl(farm, "legacy_plots"))
|
|
now_dt = _now()
|
|
now = _iso(now_dt)
|
|
|
|
set_parts = [
|
|
"coins = :post_coins",
|
|
"xp = 0",
|
|
"level = 1",
|
|
"ci_tier = 1",
|
|
"plot_count = :base_plots",
|
|
"prestige = :new_prestige",
|
|
"stars = COALESCE(stars, 0) + :stars_award",
|
|
"mastery_points = COALESCE(mastery_points, 0) + :mastery_award",
|
|
"mastery_points_earned_total = COALESCE(mastery_points_earned_total, 0) + :mastery_award",
|
|
"prestiged_at = :now",
|
|
]
|
|
params = {
|
|
"post_coins": economy.STARTING_COINS + carried,
|
|
"base_plots": base_plots,
|
|
"new_prestige": new_prestige,
|
|
"stars_award": stars_award,
|
|
"mastery_award": mastery_award,
|
|
"now": now,
|
|
"old_prestige": old_prestige,
|
|
"coins_now": coins_now,
|
|
}
|
|
for perk in economy.PERKS:
|
|
column = PERK_COLUMN[perk.key]
|
|
set_parts.append(f"{column} = 0")
|
|
|
|
rows = conditional_update_farm(
|
|
farm["uid"],
|
|
set_clause=", ".join(set_parts),
|
|
where_clause="COALESCE(prestige, 0) = :old_prestige AND coins = :coins_now",
|
|
params=params,
|
|
)
|
|
if rows == 0:
|
|
farm = get_farm(user["uid"])
|
|
if _lvl(farm, "prestige") != old_prestige:
|
|
raise GameError("Your farm already refactored - refresh and try again.")
|
|
if int(farm.get("coins", 0)) != coins_now:
|
|
raise GameError("Your coin balance just changed - refresh and try again.")
|
|
raise GameError(
|
|
f"Reach level {economy.PRESTIGE_MIN_LEVEL} to refactor (prestige)."
|
|
)
|
|
credit_treasury(fee)
|
|
|
|
kept_slots = set()
|
|
for plot in get_plots(farm["uid"]):
|
|
if int(plot.get("slot_index", 0)) >= base_plots:
|
|
_plots().delete(uid=plot["uid"])
|
|
else:
|
|
kept_slots.add(int(plot.get("slot_index", 0)))
|
|
_plots().update(
|
|
{
|
|
"uid": plot["uid"],
|
|
"crop_key": "",
|
|
"planted_at": "",
|
|
"ready_at": "",
|
|
"watered_by": "[]",
|
|
"updated_at": now,
|
|
},
|
|
["uid"],
|
|
)
|
|
for slot_index in range(base_plots):
|
|
if slot_index not in kept_slots:
|
|
_create_plot(farm["uid"], user["uid"], slot_index, now)
|
|
return {
|
|
"prestige": new_prestige,
|
|
"stars_awarded": stars_award,
|
|
"mastery_awarded": mastery_award,
|
|
"fee": fee,
|
|
"carried": carried,
|
|
}
|
|
|
|
|
|
def fertilize(user: dict, slot: int) -> dict:
|
|
farm = ensure_farm(user["uid"])
|
|
plot = _plot_at(farm["uid"], slot)
|
|
if not plot or not plot.get("crop_key"):
|
|
raise GameError("That plot is empty.")
|
|
now = _now()
|
|
if _plot_state(plot, now) != "growing":
|
|
raise GameError("That build is not running.")
|
|
crop = economy.crop_for(plot.get("crop_key", ""))
|
|
if not crop:
|
|
raise GameError("Unknown crop type.")
|
|
ready_at = _parse(plot.get("ready_at", "")) or now
|
|
remaining = max(1, int((ready_at - now).total_seconds()))
|
|
reduce_by = int(remaining * economy.FERTILIZE_FRACTION)
|
|
if reduce_by < 1:
|
|
raise GameError("That build is almost ready already.")
|
|
full_grow = economy.grow_seconds_for(
|
|
crop,
|
|
int(farm.get("ci_tier", 1)),
|
|
_lvl(farm, "perk_growth"),
|
|
_lvl(farm, "legacy_speed"),
|
|
owns_infrastructure(farm, "registry"),
|
|
)
|
|
eff_reward = economy.effective_reward_coins(
|
|
crop,
|
|
_lvl(farm, "perk_yield"),
|
|
_lvl(farm, "prestige"),
|
|
_lvl(farm, "legacy_multiplier"),
|
|
market_factor_for(crop.key),
|
|
)
|
|
cost = economy.fertilize_click_cost(eff_reward, reduce_by, full_grow)
|
|
if int(farm.get("coins", 0)) < cost:
|
|
raise GameError("Not enough coins to fertilize.")
|
|
new_ready = max(now, ready_at - timedelta(seconds=reduce_by))
|
|
_plots().update(
|
|
{"uid": plot["uid"], "ready_at": _iso(new_ready), "updated_at": _iso(now)},
|
|
["uid"],
|
|
)
|
|
_update_farm(farm["uid"], {"coins": int(farm.get("coins", 0)) - cost})
|
|
return {"slot": slot, "spent": cost, "reduced_seconds": reduce_by}
|