diff --git a/README.md b/README.md
index 2acf168..1cbe58a 100644
--- a/README.md
+++ b/README.md
@@ -28,9 +28,10 @@ Beta. The core game is in place; changes from here are mostly balance and tuning
Spine), each with four races and a boss (the dragons at the top). Every
kill is one of the race's variants (a brute, a skirmisher, a caster, now
and then a rare elite), so each encounter mixes damage types: spirit races
- lean on magic, golems and trolls on blows. Races drop rare trophies (3%,
- 6% from bosses) for stronger weapons and the area's armour reagents (10%,
+ lean on magic, golems and trolls on blows. Races drop trophies (10%,
+ 20% from bosses) for stronger weapons and the area's armour reagents (10%,
far more from dragons). Each kill is followed by a 2-second pause.
+- **Multiplayer Combat:** tag into anyone's fight from the encounter card or the guild roster.
- **Weapons:** four styles, one per trade, and anyone can use any of them.
Sword and shield (slashing, 2.4s swings, the shield blocks 15% of hits;
swords from Smithing, shields from Construction), warhammer (blunt,
diff --git a/app.py b/app.py
index 7a48aa8..a3d2939 100644
--- a/app.py
+++ b/app.py
@@ -119,11 +119,15 @@ def player_view(world: dict, player: dict, now: float) -> dict:
"crit": me["crit"], "interval": me["interval"], "block": me["block"], "damage": me["damage"]}
view["perk_costs"] = {perk: game.perk_cost(player, perk) for perk in player["perks"]}
if player["action"]:
- action, fight = game.growing(player), player["action"].get("fight")
+ action, fight = game.growing(player), game.current_fight(world, player)
duration = fight["duration"] if fight else game.action_time(world, player, action)
view["action"] = {**player["action"], "growing": action["id"], "duration": duration}
if fight:
+ view["action"]["fight"] = game.fight_view(fight)
view["action"]["respawn"] = game.RESPAWN / game.speed(world)
+ party = game.party_of(world, player)
+ if party:
+ view["action"]["with"] = [uid for uid in party["members"] if uid != player["id"]]
# A fight takes as long as it takes: show the average time to a kill.
view["times"] = {action["id"]: (view["fight_odds"][action["id"]]["kill_time"] + game.RESPAWN) / game.speed(world)
if "enemy" in action else game.action_time(world, player, action) for action in game.ACTIONS}
@@ -193,6 +197,9 @@ def roster(world: dict, now: float) -> list[dict]:
"levels": {skill: game.skill_level(player, skill) for skill in game.SKILL_IDS},
"doing": action["name"] if action else None,
"skill": action["skill"] if action else None,
+ # A fight others can tag into, and who's in it together.
+ "fight": player["action"]["id"] if game.joinable(world, player) and game.offline_limit(world, player) > now else None,
+ "party": (player["action"] or {}).get("party"),
"garrison": player["garrison"], "donated": player["donated"],
})
return sorted(people, key=lambda p: -p["donated"])
@@ -334,6 +341,8 @@ class Handler(BaseHTTPRequestHandler):
return "Bad quantity"
if path == "/api/action":
return game.start_action(world, player, str(body.get("id")), now, once=bool(body.get("once")))
+ if path == "/api/join":
+ return game.join_fight(world, player, str(body.get("id")), now)
if path == "/api/order":
return game.post_order(world, player, body.get("kind"), str(item), qty, body.get("provide"),
body.get("reward"), now)
@@ -356,7 +365,7 @@ class Handler(BaseHTTPRequestHandler):
player["seen_threat"] = max(player.get("seen_threat", 0), event_id)
return None
if path == "/api/stop":
- game.stop(player)
+ game.drop_out(world, player, now)
return None
if path == "/api/donate":
return game.donate(world, player, item, qty, now)
diff --git a/game.py b/game.py
index 13ec34d..dd2f9d3 100644
--- a/game.py
+++ b/game.py
@@ -1138,7 +1138,7 @@ RAID_TRAITS = ["lightly armoured, heavy on archers", "mounted and fast, few bows
# --- world ---------------------------------------------------------------
-WORLD_VERSION = 24
+WORLD_VERSION = 25
def new_world(now: float, speed: float = 1.0) -> dict:
@@ -1173,6 +1173,7 @@ def new_world(now: float, speed: float = 1.0) -> dict:
"board": [],
"next_message_id": 1,
"orders": [], "next_order_id": 1,
+ "parties": {}, "next_party_id": 1,
}
@@ -1326,6 +1327,14 @@ def migrate(world: dict, now: float | None = None) -> dict:
player["xp"].setdefault("firekeeping", 0)
player["equip"].setdefault("tool_firekeeping", None)
world["version"] = 24
+ if world["version"] < 25:
+ # Fighting together: fights are kept per fighter now, so the one in progress is drawn up again.
+ world.setdefault("parties", {})
+ world.setdefault("next_party_id", 1)
+ for player in world["players"].values():
+ if player["action"]:
+ player["action"].pop("fight", None)
+ world["version"] = 25
return world
@@ -1800,76 +1809,145 @@ def fight_odds(player: dict, action: dict) -> dict:
"damage": round(row["damage"], 1)} for row in rows]}
-def simulate_fight(world: dict, player: dict, action: dict, rng: random.Random) -> dict:
- """Play out one fight swing by swing, both swing timers starting empty. Nothing changes
- until it's over: the result is applied then."""
- variants = action["enemy"]["variants"]
- foe = rng.choices(variants, [v["weight"] for v in variants])[0]
+def fight_member(world: dict, player: dict, foe: dict, at: float = 0.0) -> dict:
+ """One side of a fight as it squares up (or tags in `at` seconds of game time in): kept with the
+ fight, so playing it out again later goes the same way."""
blessed, brew = blessing(player), potion_effect(player, "combat")
me = fighter(player, blessed, brew, foe)
- hit, their_hit = hit_chance(me["accuracy"], foe["evasion"]), hit_chance(foe["accuracy"], me["evasion"])
- top, hp, foe_hp = max_hp(player), player["hp"], foe["hp"]
- pantry = {item: player["bank"][item] for item in edible(player)}
- eaten, events, hurt = {}, [], 0
- wind = blessed["wind"] and not (player["action"] or {}).get("wind_used")
+ return {"id": player["id"], "name": player["name"], "at": at, "left": None,
+ "start_hp": round(player["hp"]), "top": max_hp(player), "style": me["style"],
+ "interval": me["interval"] / speed(world), "fighter": me, "hp_in": player["hp"],
+ "pantry": {item: player["bank"][item] for item in edible(player)}, "mend": blessed["mend"],
+ "wind": blessed["wind"] and not (player["action"] or {}).get("wind_used"), "pp": blessed["cost"]}
+
+
+FIGHT_PRIVATE = ("fighter", "hp_in", "pantry", "mend", "wind")
+
+
+def fight_view(fight: dict) -> dict:
+ """A fight as the page sees it: no one's bank or stats."""
+ return {**fight, "members": [{key: value for key, value in member.items() if key not in FIGHT_PRIVATE}
+ for member in fight["members"]]}
+
+
+def member_of(fight: dict, uid: str) -> dict:
+ return next(member for member in fight["members"] if member["id"] == uid)
+
+
+def draw_fight(world: dict, players: list, action: dict, rng: random.Random) -> dict:
+ """Pick the enemy and play the fight out for everyone in it."""
+ variants = action["enemy"]["variants"]
+ variant = rng.choices(range(len(variants)), [v["weight"] for v in variants])[0]
+ foe = variants[variant]
pace = speed(world)
- # A bow looses its first arrow before the enemy closes in.
- mine, theirs, result, t = (0.5 if me["first"] else me["interval"]), foe["interval"], None, 0.0
+ fight = {"seed": rng.random(), "variant": variant, "pace": pace, "enemy": foe["name"], "enemy_hp": foe["hp"],
+ "xp": foe["xp"], "enemy_interval": foe["interval"] / pace,
+ "foe": {key: foe[key] for key in ("archetype", "attack", "vulnerable", "resists")},
+ "members": [fight_member(world, player, foe) for player in players]}
+ return play_fight(action, fight)
+
+
+def simulate_fight(world: dict, player: dict, action: dict, rng: random.Random) -> dict:
+ return draw_fight(world, [player], action, rng)
+
+
+def play_fight(action: dict, fight: dict) -> dict:
+ """Play out a fight swing by swing, every swing timer starting empty (a latecomer's from when they
+ tag in). Nothing changes until it's over: the result is applied then. The dice come from the fight's
+ own seed, so playing it again with someone tagging in or stepping out changes nothing before then."""
+ rng = random.Random(fight["seed"])
+ foe = action["enemy"]["variants"][fight["variant"]]
+ pace = fight["pace"]
+ sides = []
+ for member in fight["members"]:
+ me = member["fighter"]
+ # A bow looses its first arrow before the enemy closes in.
+ sides.append({"member": member, "me": me, "hp": member["hp_in"], "pantry": dict(member["pantry"]),
+ "next": member["at"] + (0.5 if me["first"] else me["interval"]), "eaten": {}, "hurt": 0,
+ "dealt": 0, "wind": member["wind"], "out": None,
+ "hit": hit_chance(me["accuracy"], foe["evasion"]), "their_hit": hit_chance(foe["accuracy"], me["evasion"])})
+ foe_hp, theirs, events, t, won = foe["hp"], foe["interval"], [], 0.0, False
swings = 0 # an enemy with more than one attack takes turns with them
- while result is None:
- t = min(mine, theirs)
- if t > MAX_FIGHT:
- result = "fled"
+ while True:
+ # The next thing to happen: someone stepping out, someone's swing (in order of who came first), the enemy's.
+ moves = [(theirs, 2, -1)]
+ for i, side in enumerate(sides):
+ if not side["out"]:
+ if side["member"]["left"] is not None:
+ moves.append((side["member"]["left"], 0, i))
+ moves.append((side["next"], 1, i))
+ if len(moves) == 1:
break
- if mine <= theirs:
- mine += me["interval"]
- hp = min(top, hp + blessed["mend"] * top * me["interval"]) # Rapid Heal mends a little each swing
+ t, kind, i = min(moves)
+ if t > MAX_FIGHT:
+ for side in sides:
+ side["out"] = side["out"] or "fled"
+ break
+ if kind == 0:
+ sides[i]["out"] = "left"
+ continue
+ if kind == 1:
+ side, me = sides[i], sides[i]["me"]
+ top = side["member"]["top"]
+ side["next"] += me["interval"]
+ side["hp"] = min(top, side["hp"] + side["member"]["mend"] * top * me["interval"]) # Rapid Heal mends a little each swing
crit = rng.random() < me["crit"]
- landed = rng.random() < hit
+ landed = rng.random() < side["hit"]
dealt = max(1, round(me["max_hit"] * CRIT_MULT if crit else rng.randint(1, me["max_hit"]))) if landed else 0
foe_hp = max(0, foe_hp - dealt)
- events.append([round(t / pace, 2), "you", ("crit" if crit else "hit") if landed else "miss", dealt, round(hp),
- foe_hp, me["damage"]])
+ side["dealt"] += dealt
+ events.append([round(t / pace, 2), side["member"]["id"], ("crit" if crit else "hit") if landed else "miss",
+ dealt, round(side["hp"]), foe_hp, me["damage"]])
if not foe_hp:
- result = "won"
+ won = True
+ break
continue
theirs += foe["interval"]
- kind = foe["attack"][swings % len(foe["attack"])]
+ targets = [side for side in sides if not side["out"] and side["member"]["at"] <= t]
+ if not targets:
+ continue
+ side = targets[0] if len(targets) == 1 else rng.choice(targets)
+ me, uid, top = side["me"], side["member"]["id"], side["member"]["top"]
+ attack = foe["attack"][swings % len(foe["attack"])]
swings += 1
crit = rng.random() < CRIT_CHANCE
- landed = rng.random() < their_hit
+ landed = rng.random() < side["their_hit"]
if landed and rng.random() < me["block"]:
- events.append([round(t / pace, 2), "foe", "block", 0, max(0, round(hp)), foe_hp])
+ events.append([round(t / pace, 2), "foe", "block", 0, max(0, round(side["hp"])), foe_hp, attack, uid])
continue
- dealt = max(1, round((foe["max_hit"] * CRIT_MULT if crit else rng.randint(1, foe["max_hit"])) * _taken(me, kind))) \
+ dealt = max(1, round((foe["max_hit"] * CRIT_MULT if crit else rng.randint(1, foe["max_hit"])) * _taken(me, attack))) \
if landed else 0
- hp -= dealt
- hurt += dealt
- events.append([round(t / pace, 2), "foe", ("crit" if crit else "hit") if landed else "miss", dealt, max(0, round(hp)),
- foe_hp, kind])
- while hp < top * EAT_BELOW and any(pantry.values()):
+ side["hp"] -= dealt
+ side["hurt"] += dealt
+ events.append([round(t / pace, 2), "foe", ("crit" if crit else "hit") if landed else "miss", dealt,
+ max(0, round(side["hp"])), foe_hp, attack, uid])
+ pantry = side["pantry"]
+ while side["hp"] < top * EAT_BELOW and any(pantry.values()):
food = next(item for item, left in pantry.items() if left)
pantry[food] -= 1
- eaten[food] = eaten.get(food, 0) + 1
- hp = min(top, hp + ITEMS[food]["heal"])
- mine += EAT_DELAY
- events.append([round(t / pace, 2), "you", "eat", ITEMS[food]["heal"], round(hp), foe_hp, food])
- beaten, starving = hp <= 0, hp < top * FLEE_BELOW and not any(pantry.values())
- if (beaten or starving) and wind:
+ side["eaten"][food] = side["eaten"].get(food, 0) + 1
+ side["hp"] = min(top, side["hp"] + ITEMS[food]["heal"])
+ side["next"] += EAT_DELAY
+ events.append([round(t / pace, 2), uid, "eat", ITEMS[food]["heal"], round(side["hp"]), foe_hp, food])
+ beaten, starving = side["hp"] <= 0, side["hp"] < top * FLEE_BELOW and not any(pantry.values())
+ if (beaten or starving) and side["wind"]:
# Second Wind: the retreat that was coming turns into half health, once per outing.
- wind = False
- hp = top / 2
- events.append([round(t / pace, 2), "you", "wind", 0, round(hp), foe_hp])
+ side["wind"] = False
+ side["hp"] = top / 2
+ events.append([round(t / pace, 2), uid, "wind", 0, round(side["hp"]), foe_hp])
elif beaten:
- hp, result = 1, "lost"
+ side["hp"], side["out"] = 1, "lost"
elif starving:
- result = "fled"
- return {"enemy": foe["name"], "enemy_hp": foe["hp"], "top": top, "start_hp": round(player["hp"]), "xp": foe["xp"],
- "foe": {key: foe[key] for key in ("archetype", "attack", "vulnerable", "resists")},
- "hp": hp, "result": result, "end": round(t / pace, 2), "duration": t / pace,
- "interval": me["interval"] / pace, "enemy_interval": foe["interval"] / pace, "events": events, "style": me["style"],
- "eaten": eaten, "damage": hurt, "pp": blessed["cost"],
- "wind_used": blessed["wind"] and not wind and not (player["action"] or {}).get("wind_used")}
+ side["out"] = "fled"
+ for side in sides:
+ member = side["member"]
+ member.update(hp=side["hp"], eaten=side["eaten"], damage=side["hurt"], dealt=side["dealt"],
+ wind_used=member["wind"] and not side["wind"],
+ result=side["out"] or ("won" if won and member["at"] <= t else "left"))
+ standing = [side for side in sides if side["out"] not in ("left", None)]
+ fight.update(events=events, end=round(t / pace, 2), duration=t / pace,
+ result="won" if won else standing[-1]["out"] if standing else "left")
+ return fight
# --- prayer -------------------------------------------------------------------
@@ -2221,7 +2299,9 @@ def can_start(world: dict, player: dict, action: dict) -> str | None:
return None
-def _complete(world: dict, player: dict, action: dict, now: float, rng: random.Random, summary: dict) -> None:
+def _complete(world: dict, player: dict, action: dict, now: float, rng: random.Random, summary: dict,
+ fight: dict | None = None, loot: tuple | None = None) -> None:
+ """Finish one action. A shared fight comes in as `fight`, with this member's share of its `loot`."""
brew = potion_effect(player, action["skill"])
order = working_order(world, player, action)
inputs = fire_inputs(world, action)
@@ -2269,41 +2349,41 @@ def _complete(world: dict, player: dict, action: dict, now: float, rng: random.R
if "enemy" in action:
outing = player["action"]
- fight = outing.pop("fight", None) or simulate_fight(world, player, action, rng)
+ fight = fight or outing.pop("fight", None) or simulate_fight(world, player, action, rng)
outing.pop("carry", None) # from a short-lived version that ran the swing timer on
xp = fight.get("xp", action["xp"]) * mods["xp"] # the variant you met
- if player["prayers"] and not fight["pp"]:
+ mine = member_of(fight, player["id"])
+ if player["prayers"] and not mine["pp"]:
summary["prayer_out"] = True
- paid = min(player["pp"], fight["pp"])
+ paid = min(player["pp"], mine["pp"])
if paid:
player["pp"] -= paid
summary["pp_spent"] += paid
gain_xp(world, player, "prayer", paid * PRAYER_XP_PER_POINT, now, summary)
- for food, count in fight["eaten"].items():
+ for food, count in mine["eaten"].items():
count = min(count, player["bank"].get(food, 0))
if count:
bank_take(player, food, count)
summary["eaten"][food] = summary["eaten"].get(food, 0) + count
- player["hp"], player["hp_at"] = fight["hp"], now
- summary["damage"] += fight["damage"]
- if fight["wind_used"]:
+ player["hp"], player["hp_at"] = mine["hp"], now
+ summary["damage"] += mine["damage"]
+ if mine["wind_used"]:
outing["wind_used"] = True
summary["second_wind"] += 1
- if fight["result"] != "won":
+ if mine["result"] != "won":
# Beaten or out of food: fall back with nothing but your life.
summary["losses"] += 1
reason = "Retreated: ran out of food" if not edible(player) else "Retreated"
- stop(player, reason)
+ drop_out(world, player, now, reason)
summary["stopped"] = reason
gain_xp(world, player, "combat", xp // 3, now, summary)
return
summary["wins"] += 1
- gold = rng.randint(*action["gold"]) if action.get("gold") else 0
+ gold, drops = loot or roll_loot(action, rng)
player["gold"] += gold
summary["gold"] += gold
- for item, qty, odds in action.get("drops", []):
- if rng.random() < odds:
- outputs[item] = outputs.get(item, 0) + qty
+ for item, qty in drops.items():
+ outputs[item] = outputs.get(item, 0) + qty
if action.get("special") == "sabotage":
raid = upcoming_raid(world)
raid["sabotage"] = min(0.3, raid["sabotage"] + 0.03)
@@ -2402,9 +2482,17 @@ def process_player(world: dict, player: dict, now: float, rng: random.Random | N
summary = empty_summary()
collect_orders(world, player)
current = player["action"]
+ if current and current.get("party"):
+ if current["party"] in world["parties"]:
+ process_party(world, current["party"], now, rng)
+ else:
+ current.pop("party")
+ current = player["action"]
+ if current and current.get("party"):
+ return summary # a party's kills land in each member's away summary
if not current:
return summary
- limit = min(now, player["last_active"] + OFFLINE_CAP / speed(world))
+ limit = min(now, offline_limit(world, player))
while player["action"]:
action = growing(player)
if current.get("plot2") and can_start(world, player, action):
@@ -2476,16 +2564,204 @@ def stop(player: dict, reason: str | None = None) -> None:
player["stopped"] = reason
+def drop_out(world: dict, player: dict, now: float, reason: str | None = None) -> None:
+ """Stop, stepping out of a shared fight if you're in one."""
+ current = player["action"]
+ if current and current.get("party") in world["parties"]:
+ leave_party(world, player, current["party"], now)
+ stop(player, reason)
+
+
+def roll_loot(action: dict, rng: random.Random) -> tuple[int, dict]:
+ """A kill's gold and drops."""
+ gold = rng.randint(*action["gold"]) if action.get("gold") else 0
+ drops = {}
+ for item, qty, odds in action.get("drops", []):
+ if rng.random() < odds:
+ drops[item] = drops.get(item, 0) + qty
+ return gold, drops
+
+
+def share_loot(loot: tuple[int, dict], uids: list, rng: random.Random) -> dict:
+ """Gold split evenly (the odd coins to whoever's lucky), each drop to someone at random."""
+ gold, drops = loot
+ each, odd = divmod(gold, len(uids))
+ lucky = set(rng.sample(uids, odd))
+ shares = {uid: (each + (uid in lucky), {}) for uid in uids}
+ for item, qty in drops.items():
+ for _ in range(qty):
+ got = shares[rng.choice(uids)][1]
+ got[item] = got.get(item, 0) + 1
+ return shares
+
+
+# --- fighting together ------------------------------------------------------
+# Anyone can tag into someone else's fight: from then on they're a party on that
+# encounter, every enemy fought by all of them at once. Everyone gets the kill's full
+# XP; its gold is split evenly and each drop goes to someone at random. The party
+# lasts until all but one have left (stopped, retreated, or been away too long), and
+# the last one carries on alone.
+
+def offline_limit(world: dict, player: dict) -> float:
+ return player["last_active"] + OFFLINE_CAP / speed(world)
+
+
+def joinable(world: dict, player: dict) -> bool:
+ """Whether someone's fight is one others can tag into."""
+ current = player["action"]
+ if not current or "left" in current or "order" in current:
+ return False
+ action = ACTION_BY_ID[current["id"]]
+ return "enemy" in action and not action.get("special")
+
+
+def current_fight(world: dict, player: dict) -> dict | None:
+ current = player["action"] or {}
+ party = world["parties"].get(current.get("party"))
+ return party["fight"] if party else current.get("fight")
+
+
+def party_of(world: dict, player: dict) -> dict | None:
+ return world["parties"].get((player["action"] or {}).get("party"))
+
+
+def join_fight(world: dict, player: dict, uid: str, now: float) -> str | None:
+ """Tag into someone's fight, swinging at the enemy they're on right now."""
+ host = world["players"].get(uid)
+ if not host or host is player:
+ return "No one to join"
+ if not joinable(world, host):
+ return f"{host['name']} isn't fighting"
+ if offline_limit(world, host) <= now:
+ return f"{host['name']} is away"
+ party = party_of(world, host)
+ if party and party is party_of(world, player):
+ return "Already fighting together"
+ action = ACTION_BY_ID[host["action"]["id"]]
+ reason = can_start(world, player, action)
+ if reason:
+ return reason
+ if party_of(world, player):
+ leave_party(world, player, player["action"]["party"], now)
+ if not party:
+ # Someone fighting alone becomes a party of one, their fight as it stands.
+ pid = str(world["next_party_id"])
+ world["next_party_id"] += 1
+ solo = host["action"]
+ party = world["parties"][pid] = {"id": pid, "action": solo["id"], "members": [host["id"]],
+ "start": solo["start"], "fight": solo.pop("fight", None)}
+ solo["party"] = pid
+ party["members"].append(player["id"])
+ player["action"] = {"id": party["action"], "start": party["start"], "party": party["id"]}
+ player["stopped"] = None
+ fight = party["fight"]
+ if fight and now < party["start"] + fight["duration"]:
+ at = max(0.0, (now - party["start"]) * fight["pace"])
+ foe = action["enemy"]["variants"][fight["variant"]]
+ fight["members"].append(fight_member(world, player, foe, at))
+ play_fight(action, fight)
+ log(world, now, "party", f"{player['name']} joined {host['name']}: {action['name']}", player["id"])
+ return None
+
+
+def leave_party(world: dict, player: dict, pid: str, now: float) -> None:
+ """Step out of a party at `now`. The fight goes on without you (you get nothing from it); whoever's
+ left alone carries on by themselves. Setting your own action is up to the caller."""
+ party = world["parties"][pid]
+ party["members"].remove(player["id"])
+ fight = party["fight"]
+ if fight and now < party["start"] + fight["duration"]:
+ action = ACTION_BY_ID[party["action"]]
+ member = member_of(fight, player["id"])
+ if now <= party["start"] or len(fight["members"]) == 1:
+ fight["members"].remove(member)
+ else:
+ member["left"] = max(member["at"], (now - party["start"]) * fight["pace"])
+ party["fight"] = play_fight(action, fight) if party["members"] and fight["members"] else None
+ if len(party["members"]) <= 1:
+ del world["parties"][pid]
+ for uid in party["members"]:
+ last = world["players"][uid]["action"]
+ last.pop("party", None)
+ last.update(start=party["start"], **({"fight": party["fight"]} if party["fight"] else {}))
+
+
+def process_party(world: dict, pid: str, now: float, rng: random.Random) -> None:
+ """Run a party's fights forward to `now`: every kill lands for everyone in it at once. What
+ each member gets waits in their away summary."""
+ party = world["parties"][pid]
+ action = ACTION_BY_ID[party["action"]]
+ for uid in list(party["members"]):
+ if (world["players"][uid]["action"] or {}).get("party") != pid and world["parties"].get(pid) is party:
+ leave_party(world, world["players"][uid], pid, party["start"]) # moved on without saying
+ while world["parties"].get(pid) is party:
+ members = [world["players"][uid] for uid in party["members"]]
+ if not party["fight"]:
+ for player in members:
+ regen(world, player, party["start"])
+ reason = can_start(world, player, action)
+ if reason and reason.startswith("Too hurt"):
+ if blessing(player)["wind"] and not player["action"].get("wind_used"):
+ # Second Wind: the retreat that was coming turns into half health.
+ player["action"]["wind_used"] = True
+ player["hp"] = max_hp(player) / 2
+ player.setdefault("away", empty_summary())["second_wind"] += 1
+ reason = None
+ else:
+ reason = "Retreated: hurt and out of food"
+ if reason:
+ drop_out(world, player, party["start"], reason)
+ player.setdefault("away", empty_summary())["stopped"] = reason
+ if world["parties"].get(pid) is not party:
+ break
+ members = [world["players"][uid] for uid in party["members"]]
+ party["fight"] = draw_fight(world, members, action, rng)
+ end = party["start"] + party["fight"]["duration"]
+ late = [player for player in members if offline_limit(world, player) < min(end, now)]
+ if late:
+ # Away too long: they step out where their time ran out, and pick up alone when they're back.
+ for player in late:
+ if world["parties"].get(pid) is not party:
+ break # the last of them carries on alone, and picks up when they're back
+ at = max(party["start"], offline_limit(world, player))
+ wind = {"wind_used": True} if player["action"].get("wind_used") else {}
+ leave_party(world, player, pid, at)
+ player["action"] = {"id": action["id"], "start": at, **wind}
+ continue
+ if end > now:
+ break
+ burn_fires(world, end)
+ fight, party["fight"] = party["fight"], None
+ party["start"] = end + RESPAWN / speed(world) # a moment before the next enemy turns up
+ for player in members:
+ player["action"]["start"] = party["start"]
+ results = {m["id"]: m["result"] for m in fight["members"]}
+ winners = [uid for uid in party["members"] if results.get(uid) == "won"]
+ shares = share_loot(roll_loot(action, rng), winners, rng) if winners else {}
+ for player in members:
+ if results.get(player["id"], "left") == "left":
+ continue
+ summary = player.setdefault("away", empty_summary())
+ _complete(world, player, action, end, rng, summary, fight=fight, loot=shares.get(player["id"]))
+ summary["done"] += 1
+ together = summary.setdefault("with", {})
+ for other in members:
+ if other is not player:
+ together[other["name"]] = together.get(other["name"], 0) + 1
+
+
def catch_up(world: dict, now: float, rng: random.Random | None = None) -> bool:
"""Run everyone's actions up to now, so the shared fires see feeds and crafts as they
happen. What each player missed waits in their `away` summary for their next visit."""
changed = False
+ parties = lambda: {pid: party["start"] for pid, party in world["parties"].items()}
+ before = parties()
for player in world["players"].values():
summary = process_player(world, player, now, rng)
if summary["done"] or summary["stopped"]:
merge_summary(player.setdefault("away", empty_summary()), summary)
changed = True
- return changed
+ return changed or parties() != before
def merge_summary(into: dict, more: dict) -> dict:
@@ -2705,6 +2981,8 @@ def work_order(world: dict, player: dict, order_id, now: float) -> str | None:
if not had:
order["claimed"] = None # couldn't start: don't sit on it
return reason
+ if previous and previous.get("party") in world["parties"]:
+ leave_party(world, player, previous["party"], now)
player["stopped"] = None
return None
@@ -2813,6 +3091,8 @@ def start_action(world: dict, player: dict, action_id: str, now: float, once: bo
elif current and current.get("plot2") and current["plot2"] != action_id and action["skill"] == "farming":
# Replanting the first plot leaves the second one growing.
entry.update(plot2=current["plot2"], turn=0)
+ if current and current.get("party") in world["parties"]:
+ leave_party(world, player, current["party"], now)
player["action"] = entry
player["stopped"] = None
return None
@@ -4469,6 +4749,9 @@ PATCH_NOTES = [
"the fire is lit, the Firekeeper gains 10% of the XP the craft gave the crafter, shared between all players keeping a "
"fire of that tier. Each player keeps their own \"pile\", which contributes an equal amount to the fire."),
("new", "Work orders: anyone can provide reagents towards an incomplete work order and gets paid based on the value of the items provided."),
+ ("new", "Fight together: tag into anyone's fight from the encounter card or the guild roster. You all swing at the same enemy, "
+ "live on everyone's screen, so kills come faster. Everyone gets the full XP for each kill; the gold is split evenly and "
+ "each drop goes to one of you at random. Leave any time, and whoever's left fights on alone."),
("balance", "Gear: combat requirement adjusted to match the tier of crafting required to make it."),
("balance", "Combat XP reduced to keep it in line with professions. Eating now delays your next swing; eat higher tier food to reduce the impact."),
("balance", "Construction workbench now also affects labour on building sites."),
diff --git a/static/app.js b/static/app.js
index 96f5e3c..3f4a7b0 100644
--- a/static/app.js
+++ b/static/app.js
@@ -4,6 +4,7 @@
// between polls. The server is the source of truth for everything.
const POLL_MS = 10000;
+const FIGHT_POLL_MS = 2000; // in a fight someone may tag in: keep everyone's view of it close
const SUMMARY_MODAL_AT = 25;
let C = null; // static content tables
@@ -21,6 +22,8 @@ let pickedClass = null; // registration
const tabs = {}; // skill -> selected recipe tab
let refreshing = false;
let refreshedFor = null; // action (start and length) a completion refresh was sent for
+let polledAt = 0;
+let tagging = false; // this page just tagged into someone's fight
let retriedAt = 0; // last time a fight past its kill asked again for the next one
let version = null; // server build this page was loaded from
let failures = 0; // polls in a row that didn't reach the server
@@ -77,6 +80,7 @@ async function act(path, body) {
async function refresh() {
if (refreshing) return;
refreshing = true;
+ polledAt = Date.now();
try {
accept(await api("/api/state"));
failures = 0;
@@ -95,8 +99,14 @@ function accept(state) {
location.reload(); // a new build was deployed
return;
}
+ // Someone tagging into your fight (not you tagging into theirs) gets a toast.
+ const fightingWith = S?.me && !tagging ? S.me.action?.with || [] : null;
+ tagging = false;
S = state;
skew = state.now - Date.now() / 1000;
+ for (const uid of fightingWith ? state.me?.action?.with || [] : []) {
+ if (!fightingWith.includes(uid)) toast(`⚔️ ${playerName(uid)} joined the fight`, "good");
+ }
if (state.summary) showSummary(state.summary);
orderNews(state);
const ev = state.upcoming;
@@ -180,6 +190,7 @@ function awayModal(sum) {
openModal(`
`;
});
@@ -1014,7 +1045,7 @@ function actionCard(a) {
let extra = "";
if (a.enemy) {
const o = me.fight_odds[a.id], e = a.enemy;
- extra = `${e.boss ? `
Boss
` : ""}${variantRows(e, o)}`;
+ extra = `${e.boss ? `
Boss
` : ""}${variantRows(e, o)}${fightingHere(a, why)}`;
if (a.gold) io += `${COIN} ${a.gold[0]}–${a.gold[1]}`;
if (a.drops) io += a.drops.map(chance).join("");
if (a.special === "sabotage") extra += `