add blue archive gacha simulator cog with live banners and wiki portraits
This commit is contained in:
esef committed
1 parent
c2133705fe
commit
95228a425d
9 files changed
+1045
-29
No files matched your search
@@ -0,0 +1 @@
|
||||
"""Blue Archive gacha simulator package."""
|
||||
@@ -0,0 +1,212 @@
|
||||
#this module loads student data and fetches live banner info from the api##
|
||||
"""Student and banner data layer for the Blue Archive gacha simulator."""
|
||||
######################################################################
|
||||
import hashlib
|
||||
import json
|
||||
import logging
|
||||
import random
|
||||
import urllib.parse
|
||||
from datetime import datetime, timezone
|
||||
from pathlib import Path
|
||||
from typing import Optional
|
||||
|
||||
import aiohttp
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
BUNDLED_DB = Path(__file__).parent / "ba_students.json"
|
||||
BANNER_API = "https://api.ennead.cc/buruaka/banner"
|
||||
SCHALE_PORTRAIT = "https://raw.githubusercontent.com/SchaleDB/SchaleDB/main/images/student/portrait"
|
||||
SCHALE_ICON = "https://raw.githubusercontent.com/SchaleDB/SchaleDB/main/images/student/icon"
|
||||
|
||||
# Wiki portrait CDN: static.wikitide.net/bluearchivewiki/{md5[0]}/{md5[:2]}/{filename}
|
||||
WIKI_CDN = "https://static.wikitide.net/bluearchivewiki"
|
||||
|
||||
# schaleDB Name → wiki Portrait_ filename (without .png extension)
|
||||
# Most work automatically by replacing spaces with underscores; these are the exceptions.
|
||||
WIKI_NAME_MAP: dict[str, str] = {
|
||||
"Aris": "Arisu",
|
||||
"Shiroko (Cycling)": "Shiroko_(Riding)",
|
||||
"Shun (Small)": "Shun_(Kid)",
|
||||
"Neru (Bunny)": "Neru_(Bunny_Girl)",
|
||||
"Karin (Bunny)": "Karin_(Bunny_Girl)",
|
||||
"Asuna (Bunny)": "Asuna_(Bunny_Girl)",
|
||||
"Utaha (Cheer Squad)": "Utaha_(Cheerleader)",
|
||||
"Hibiki (Cheer Squad)": "Hibiki_(Cheerleader)",
|
||||
"Akane (Bunny)": "Akane_(Bunny_Girl)",
|
||||
"Aris (Maid)": "Arisu_(Maid)",
|
||||
"Toki (Bunny)": "Toki_(Bunny_Girl)",
|
||||
"Kotori (Cheer Squad)": "Kotori_(Cheerleader)",
|
||||
"Kotama (Camp)": "Kotama_(Camping)",
|
||||
"Hare (Camp)": "Hare_(Camping)",
|
||||
"Shiroko Terror": "Shiroko_(Terror)",
|
||||
# Track variants — no wiki portrait; fall back to SchaleDB
|
||||
}
|
||||
|
||||
|
||||
def _wiki_filename(student: dict) -> str:
|
||||
"""Build the wiki Portrait_ filename (no extension) for a student."""
|
||||
name = student["Name"]
|
||||
mapped = WIKI_NAME_MAP.get(name)
|
||||
if mapped is not None:
|
||||
return mapped
|
||||
return name.replace(" ", "_")
|
||||
|
||||
|
||||
def wiki_portrait_url(student: dict) -> str:
|
||||
"""Compute the CDN URL for a student's wiki portrait (252x204 face image)."""
|
||||
filename = f"Portrait_{_wiki_filename(student)}.png"
|
||||
h = hashlib.md5(filename.encode()).hexdigest()
|
||||
return f"{WIKI_CDN}/{h[0]}/{h[:2]}/{urllib.parse.quote(filename)}"
|
||||
|
||||
|
||||
def schale_portrait_url(student_id: int) -> str:
|
||||
"""Full-body sprite URL (fallback if wiki portrait is unavailable)."""
|
||||
return f"{SCHALE_PORTRAIT}/{student_id}.webp"
|
||||
PORTRAIT_BASE = "https://raw.githubusercontent.com/SchaleDB/SchaleDB/main/images/student/portrait"
|
||||
ICON_BASE = "https://raw.githubusercontent.com/SchaleDB/SchaleDB/main/images/student/icon"
|
||||
|
||||
|
||||
class StudentDB:
|
||||
"""In-memory student database loaded from the bundled SchaleDB JSON."""
|
||||
|
||||
def __init__(self) -> None:
|
||||
self.students: list[dict] = []
|
||||
self.by_id: dict[int, dict] = {}
|
||||
self.by_name: dict[str, dict] = {}
|
||||
self.by_rarity: dict[int, list[dict]] = {1: [], 2: [], 3: []}
|
||||
self._loaded = False
|
||||
|
||||
def load(self) -> None:
|
||||
if self._loaded:
|
||||
return
|
||||
with open(BUNDLED_DB, "r", encoding="utf-8") as f:
|
||||
self.students = json.load(f)
|
||||
|
||||
for s in self.students:
|
||||
sid = s["Id"]
|
||||
name = s["Name"].lower()
|
||||
rarity = s["StarGrade"]
|
||||
|
||||
self.by_id[sid] = s
|
||||
self.by_name[name] = s
|
||||
if rarity in self.by_rarity:
|
||||
self.by_rarity[rarity].append(s)
|
||||
|
||||
self._loaded = True
|
||||
log.info(
|
||||
"Loaded %d students (1*: %d, 2*: %d, 3*: %d)",
|
||||
len(self.students),
|
||||
len(self.by_rarity[1]),
|
||||
len(self.by_rarity[2]),
|
||||
len(self.by_rarity[3]),
|
||||
)
|
||||
|
||||
def get(self, student_id: int) -> Optional[dict]:
|
||||
return self.by_id.get(student_id)
|
||||
|
||||
def get_by_name(self, name: str) -> Optional[dict]:
|
||||
return self.by_name.get(name.lower())
|
||||
|
||||
def random_by_rarity(self, rarity: int) -> dict:
|
||||
"""Pick a random student of the given base rarity (1, 2, or 3)."""
|
||||
pool = self.by_rarity.get(rarity, [])
|
||||
if not pool:
|
||||
# Fallback: any student
|
||||
pool = self.students
|
||||
return random.choice(pool)
|
||||
|
||||
def wiki_portrait(self, student: dict) -> str:
|
||||
"""Wiki face-portrait CDN URL for a student dict (252x204)."""
|
||||
return wiki_portrait_url(student)
|
||||
|
||||
def schale_portrait(self, student_id: int) -> str:
|
||||
"""SchaleDB full-body sprite URL (fallback)."""
|
||||
return schale_portrait_url(student_id)
|
||||
|
||||
|
||||
# Global singleton
|
||||
db = StudentDB()
|
||||
|
||||
|
||||
# --- Banner types & rates ---------------------------------------------------
|
||||
|
||||
# In-game rates per banner type
|
||||
# Format: { gachaType: (rate_3star, rate_2star, rate_1star) }
|
||||
# Fes banners double the 3-star rate to 6%
|
||||
BANNER_RATES: dict[str, tuple[float, float, float]] = {
|
||||
"FesGacha": (0.06, 0.185, 0.755),
|
||||
}
|
||||
DEFAULT_RATES = (0.03, 0.185, 0.785)
|
||||
|
||||
# The 10th pull on a 10-pull: guarantee at least 2-star
|
||||
# (97% 2-star, 3% 3-star — the 1-star rate is redirected into 2-star)
|
||||
PULL10_RATES = (0.03, 0.97, 0.0)
|
||||
|
||||
|
||||
def roll_rarity(rates: tuple[float, float, float]) -> int:
|
||||
"""Roll rarity tier given (p_3star, p_2star, p_1star). Returns 3, 2, or 1."""
|
||||
r = random.random()
|
||||
if r < rates[0]:
|
||||
return 3
|
||||
elif r < rates[0] + rates[1]:
|
||||
return 2
|
||||
else:
|
||||
return 1
|
||||
|
||||
|
||||
def get_rates_for_banner(banner: dict) -> tuple[float, float, float]:
|
||||
"""Return (3star_rate, 2star_rate, 1star_rate) for a banner's gachaType."""
|
||||
return BANNER_RATES.get(banner.get("gachaType", ""), DEFAULT_RATES)
|
||||
|
||||
|
||||
# --- Banner fetching ---------------------------------------------------------
|
||||
|
||||
async def fetch_banners(session: Optional[aiohttp.ClientSession] = None) -> dict:
|
||||
"""Fetch live banner data from the BlueArchiveAPI.
|
||||
|
||||
Returns the parsed JSON: {"current": [...], "upcoming": [...], "ended": [...]}
|
||||
"""
|
||||
close_session = session is None
|
||||
if close_session:
|
||||
session = aiohttp.ClientSession()
|
||||
|
||||
try:
|
||||
async with session.get(BANNER_API) as resp:
|
||||
if resp.status == 200:
|
||||
data = await resp.json()
|
||||
log.info("Fetched %d current, %d upcoming banners",
|
||||
len(data.get("current", [])),
|
||||
len(data.get("upcoming", [])))
|
||||
return data
|
||||
else:
|
||||
log.warning("Banner API returned status %d", resp.status)
|
||||
return {"current": [], "upcoming": [], "ended": []}
|
||||
except Exception:
|
||||
log.exception("Failed to fetch banners from API")
|
||||
return {"current": [], "upcoming": [], "ended": []}
|
||||
finally:
|
||||
if close_session:
|
||||
await session.close()
|
||||
|
||||
|
||||
def format_banner_embed(banner: dict, index: int) -> str:
|
||||
"""Format a single banner as an embed field value string."""
|
||||
gtype = banner.get("gachaType", "PickupGacha")
|
||||
rateups = ", ".join(banner.get("rateups", [])) or "Standard pool"
|
||||
started = banner.get("startedAt", 0)
|
||||
ended = banner.get("endedAt", 0)
|
||||
|
||||
if started and ended:
|
||||
start_dt = datetime.fromtimestamp(started / 1000, tz=timezone.utc)
|
||||
end_dt = datetime.fromtimestamp(ended / 1000, tz=timezone.utc)
|
||||
dates = f"{start_dt.strftime('%b %d')} – {end_dt.strftime('%b %d, %Y')}"
|
||||
else:
|
||||
dates = "Permanent"
|
||||
|
||||
is_fes = " [FES - 6% 3*!]" if gtype == "FesGacha" else ""
|
||||
return (
|
||||
f"**#{index + 1} — {gtype}{is_fes}**\n"
|
||||
f"Rate-up: {rateups}\n"
|
||||
f"{dates}"
|
||||
)
|
||||
@@ -0,0 +1,386 @@
|
||||
#this is the gacha cog for blue archive, handles all recruitment commands##
|
||||
"""Blue Archive Gacha Simulator — in-game-accurate recruitment with live banners."""
|
||||
######################################################################
|
||||
import asyncio
|
||||
import json
|
||||
import logging
|
||||
import random
|
||||
from pathlib import Path
|
||||
from typing import Optional
|
||||
|
||||
import discord
|
||||
from discord.ext import commands
|
||||
|
||||
from .data import (
|
||||
db,
|
||||
fetch_banners,
|
||||
format_banner_embed,
|
||||
roll_rarity,
|
||||
get_rates_for_banner,
|
||||
PULL10_RATES,
|
||||
DEFAULT_RATES,
|
||||
)
|
||||
from .gacha_renderer import render_pull
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
STATE_FILE = Path("data/ba_gacha_state.json")
|
||||
SPARK_TARGET = 200
|
||||
_state_lock = asyncio.Lock()
|
||||
|
||||
|
||||
def _load_state() -> dict:
|
||||
"""Load per-user gacha state from disk."""
|
||||
if STATE_FILE.exists():
|
||||
with open(STATE_FILE, "r") as f:
|
||||
return json.load(f)
|
||||
return {}
|
||||
|
||||
|
||||
def _save_state(state: dict) -> None:
|
||||
"""Persist per-user gacha state to disk."""
|
||||
STATE_FILE.parent.mkdir(parents=True, exist_ok=True)
|
||||
with open(STATE_FILE, "w") as f:
|
||||
json.dump(state, f, indent=2)
|
||||
|
||||
|
||||
async def _get_user_state(user_id: int) -> dict:
|
||||
async with _state_lock:
|
||||
state = _load_state()
|
||||
key = str(user_id)
|
||||
if key not in state:
|
||||
state[key] = {"banner_id": None, "spark": 0, "history": []}
|
||||
return state[key]
|
||||
|
||||
|
||||
async def _set_user_state(user_id: int, user_state: dict) -> None:
|
||||
async with _state_lock:
|
||||
state = _load_state()
|
||||
state[str(user_id)] = user_state
|
||||
_save_state(state)
|
||||
|
||||
|
||||
class BlueArchiveGacha(commands.Cog):
|
||||
"""Blue Archive recruitment simulator with live banners and in-game-style renders."""
|
||||
|
||||
def __init__(self, bot: commands.Bot) -> None:
|
||||
self.bot = bot
|
||||
self._banner_cache: dict = {"current": [], "upcoming": [], "ended": []}
|
||||
self._cache_ready = asyncio.Event()
|
||||
|
||||
# ── Lifecycle ───────────────────────────────────────────────────────
|
||||
|
||||
async def cog_load(self) -> None:
|
||||
"""Load student DB and fetch banners on startup."""
|
||||
db.load()
|
||||
await self._refresh_banners()
|
||||
# Background refresh every 6 hours
|
||||
self._refresh_task = self.bot.loop.create_task(self._periodic_refresh())
|
||||
|
||||
async def cog_unload(self) -> None:
|
||||
self._refresh_task.cancel()
|
||||
|
||||
async def _refresh_banners(self) -> None:
|
||||
try:
|
||||
self._banner_cache = await fetch_banners()
|
||||
except Exception:
|
||||
log.exception("Banner refresh failed")
|
||||
finally:
|
||||
self._cache_ready.set() # always unblock waiters, even on failure
|
||||
|
||||
async def _periodic_refresh(self) -> None:
|
||||
while True:
|
||||
await asyncio.sleep(6 * 3600) # 6 hours
|
||||
await self._refresh_banners()
|
||||
|
||||
def _all_banners(self) -> list[dict]:
|
||||
"""Return a flat list of all available (current + upcoming) banners for picking."""
|
||||
return self._banner_cache.get("current", []) + self._banner_cache.get("upcoming", [])
|
||||
|
||||
# ── Commands ────────────────────────────────────────────────────────
|
||||
|
||||
@commands.group(name="gacha", aliases=["banners", "g"], invoke_without_command=True)
|
||||
async def gacha(self, ctx: commands.Context) -> None:
|
||||
"""Show live recruitment banners. Use subcommands: pick, info."""
|
||||
try:
|
||||
await asyncio.wait_for(self._cache_ready.wait(), timeout=15.0)
|
||||
except asyncio.TimeoutError:
|
||||
pass # proceed with whatever we have
|
||||
banners = self._all_banners()
|
||||
|
||||
if not banners:
|
||||
embed = discord.Embed(
|
||||
title="Recruitment",
|
||||
description="No active banners available right now.\n"
|
||||
"Try the permanent **Regular Recruitment** banner instead:\n"
|
||||
"`!gacha pick regular`",
|
||||
color=0x5BA0D0,
|
||||
)
|
||||
await ctx.reply(embed=embed)
|
||||
return
|
||||
|
||||
# Build embed
|
||||
embed = discord.Embed(
|
||||
title="Recruitment — Available Banners",
|
||||
description="Use `!gacha pick <number>` to select a banner, then `!pull` to recruit!\n"
|
||||
"Or `!gacha pick regular` for the permanent banner.\n"
|
||||
"`!gacha info` to see your status.",
|
||||
color=0x5BA0D0,
|
||||
)
|
||||
|
||||
for i, banner in enumerate(banners[:8]): # Discord embed field limit
|
||||
embed.add_field(
|
||||
name="",
|
||||
value=format_banner_embed(banner, i),
|
||||
inline=False,
|
||||
)
|
||||
|
||||
embed.set_footer(text="Banner data from BlueArchiveAPI • Updates every 6 hours")
|
||||
await ctx.reply(embed=embed)
|
||||
|
||||
@gacha.command(name="pick")
|
||||
async def gacha_pick(self, ctx: commands.Context, *, choice: str = "") -> None:
|
||||
"""Select your active recruitment banner.
|
||||
|
||||
Usage: !gacha pick <number> or !gacha pick regular
|
||||
"""
|
||||
choice = choice.strip().lower()
|
||||
if not choice:
|
||||
await ctx.reply("Usage: `!gacha pick <number>` or `!gacha pick regular`")
|
||||
return
|
||||
|
||||
if choice == "regular":
|
||||
user_state = await _get_user_state(ctx.author.id)
|
||||
user_state["banner_id"] = "regular"
|
||||
await _set_user_state(ctx.author.id, user_state)
|
||||
await ctx.reply(
|
||||
"Active banner set to **Regular Recruitment** (permanent pool, no rate-up).\n"
|
||||
"Use `!pull` to recruit!"
|
||||
)
|
||||
return
|
||||
|
||||
# Try numeric pick from banner list
|
||||
try:
|
||||
idx = int(choice) - 1
|
||||
except ValueError:
|
||||
await ctx.reply("Usage: `!gacha pick <number>` or `!gacha pick regular`")
|
||||
return
|
||||
|
||||
try:
|
||||
await asyncio.wait_for(self._cache_ready.wait(), timeout=15.0)
|
||||
except asyncio.TimeoutError:
|
||||
pass
|
||||
banners = self._all_banners()
|
||||
|
||||
if idx < 0 or idx >= len(banners):
|
||||
await ctx.reply(f"Invalid banner number. There are {len(banners)} banners available (1–{len(banners)}).")
|
||||
return
|
||||
|
||||
banner = banners[idx]
|
||||
rateups = ", ".join(banner.get("rateups", [])) or "Standard Pool"
|
||||
gtype = banner.get("gachaType", "PickupGacha")
|
||||
|
||||
user_state = await _get_user_state(ctx.author.id)
|
||||
user_state["banner_id"] = banner["id"]
|
||||
user_state["spark"] = 0 # reset spark on banner switch
|
||||
await _set_user_state(ctx.author.id, user_state)
|
||||
|
||||
await ctx.reply(
|
||||
f"Active banner: **{gtype}**\n"
|
||||
f"Rate-up: {rateups}\n"
|
||||
f"Spark count reset to 0. Use `!pull` to recruit!"
|
||||
)
|
||||
|
||||
@commands.command(name="pull")
|
||||
async def pull_gacha(self, ctx: commands.Context, *, mode: str = "10") -> None:
|
||||
"""Perform a gacha pull. Default is 10-pull.
|
||||
|
||||
Usage: !pull (10-pull)
|
||||
!pull single (1-pull)
|
||||
"""
|
||||
mode = mode.strip().lower()
|
||||
if mode in ("single", "1", "one"):
|
||||
count = 1
|
||||
else:
|
||||
count = 10
|
||||
|
||||
user_state = await _get_user_state(ctx.author.id)
|
||||
banner_id = user_state.get("banner_id")
|
||||
|
||||
# Determine banner info
|
||||
try:
|
||||
await asyncio.wait_for(self._cache_ready.wait(), timeout=15.0)
|
||||
except asyncio.TimeoutError:
|
||||
pass
|
||||
banner = None
|
||||
banner_name = "Regular Recruitment"
|
||||
rates = DEFAULT_RATES
|
||||
|
||||
if banner_id and banner_id != "regular":
|
||||
for b in self._all_banners():
|
||||
if b["id"] == banner_id:
|
||||
banner = b
|
||||
break
|
||||
if banner:
|
||||
rateups = ", ".join(banner.get("rateups", [])) or "Standard Pool"
|
||||
gtype = banner.get("gachaType", "PickupGacha")
|
||||
banner_name = f"{gtype} — {rateups}"
|
||||
rates = get_rates_for_banner(banner)
|
||||
|
||||
# "Opening envelope" teaser
|
||||
teaser = await ctx.reply("Opening recruitment envelope" + ("s..." if count > 1 else "..."))
|
||||
|
||||
# Perform pulls
|
||||
pulls = []
|
||||
for i in range(count):
|
||||
# 10th pull guarantee
|
||||
r = rates
|
||||
if count == 10 and i == 9:
|
||||
r = PULL10_RATES
|
||||
|
||||
rarity = roll_rarity(r)
|
||||
student = db.random_by_rarity(rarity)
|
||||
|
||||
# Check for rate-up weighting (simplified: 30% chance to hit rate-up if 3★)
|
||||
if banner and rarity == 3 and banner.get("rateups"):
|
||||
rateup_names = [n.lower() for n in banner["rateups"]]
|
||||
if random.random() < 0.30:
|
||||
# Try to find the rate-up student in our DB
|
||||
for rn in rateup_names:
|
||||
s = db.get_by_name(rn)
|
||||
if s and s["StarGrade"] == 3:
|
||||
student = s
|
||||
break
|
||||
|
||||
pulls.append(student)
|
||||
|
||||
# Update spark
|
||||
user_state["spark"] = user_state.get("spark", 0) + count
|
||||
# Trim history to last 50
|
||||
history = user_state.get("history", [])
|
||||
history.extend(p["Id"] for p in pulls)
|
||||
user_state["history"] = history[-50:]
|
||||
await _set_user_state(ctx.author.id, user_state)
|
||||
|
||||
# Render result image
|
||||
spark = user_state["spark"]
|
||||
async with ctx.typing():
|
||||
img_bytes = await render_pull(pulls, banner_name, spark)
|
||||
|
||||
# Build summary embed
|
||||
rarity_counts = {3: 0, 2: 0, 1: 0}
|
||||
for p in pulls:
|
||||
rarity_counts[p["StarGrade"]] += 1
|
||||
|
||||
summary_lines = [f"{p['StarGrade']}★ {p['Name']}" for p in pulls]
|
||||
summary_text = "\n".join(summary_lines)
|
||||
|
||||
best = max(pulls, key=lambda p: p["StarGrade"])
|
||||
embed = discord.Embed(
|
||||
title=f"{count}x Recruitment Result",
|
||||
description=summary_text,
|
||||
color={
|
||||
3: 0xF0C040,
|
||||
2: 0xB478DC,
|
||||
1: 0x64A0DC,
|
||||
}.get(best["StarGrade"], 0x5BA0D0),
|
||||
)
|
||||
embed.add_field(
|
||||
name="Summary",
|
||||
value=f"3★: {rarity_counts[3]} | 2★: {rarity_counts[2]} | 1★: {rarity_counts[1]}",
|
||||
)
|
||||
embed.add_field(name="Banner", value=banner_name, inline=False)
|
||||
embed.add_field(
|
||||
name="Recruitment Points",
|
||||
value=f"{spark}/{SPARK_TARGET} {'-- Spark Ready!' if spark >= SPARK_TARGET else ''}",
|
||||
)
|
||||
embed.set_footer(text=f"Top pull: {best['StarGrade']}★ {best['Name']} ({best.get('School', '')})")
|
||||
|
||||
# Send image and embed
|
||||
file = discord.File(img_bytes, filename="gacha_result.png")
|
||||
embed.set_image(url="attachment://gacha_result.png")
|
||||
try:
|
||||
await teaser.delete()
|
||||
except (discord.NotFound, discord.Forbidden):
|
||||
pass
|
||||
await ctx.reply(file=file, embed=embed)
|
||||
|
||||
@commands.command(name="spark")
|
||||
async def spark(self, ctx: commands.Context, *, character_name: str = "") -> None:
|
||||
"""Claim a rate-up student from your active banner (costs 200 recruitment points).
|
||||
|
||||
Usage: !spark <character name>
|
||||
"""
|
||||
if not character_name:
|
||||
await ctx.reply("Usage: `!spark <character name>` — e.g., `!spark Aru`")
|
||||
return
|
||||
|
||||
user_state = await _get_user_state(ctx.author.id)
|
||||
spark = user_state.get("spark", 0)
|
||||
|
||||
if spark < SPARK_TARGET:
|
||||
await ctx.reply(
|
||||
f"You need {SPARK_TARGET} recruitment points to spark. You have {spark}."
|
||||
)
|
||||
return
|
||||
|
||||
# Check if character exists
|
||||
student = db.get_by_name(character_name)
|
||||
if not student:
|
||||
await ctx.reply(f"Character **{character_name}** not found in the database.")
|
||||
return
|
||||
|
||||
# Deduct spark
|
||||
user_state["spark"] = spark - SPARK_TARGET
|
||||
await _set_user_state(ctx.author.id, user_state)
|
||||
|
||||
await ctx.reply(
|
||||
f"**Spark!** You claimed **{student['Name']}** ({student['StarGrade']}*, {student.get('School', 'Unknown')})!\n"
|
||||
f"Remaining recruitment points: {user_state['spark']}"
|
||||
)
|
||||
|
||||
@gacha.command(name="info")
|
||||
async def gacha_info(self, ctx: commands.Context) -> None:
|
||||
"""Show your current gacha state — active banner, spark count, and recent pulls."""
|
||||
user_state = await _get_user_state(ctx.author.id)
|
||||
banner_id = user_state.get("banner_id", "regular")
|
||||
spark = user_state.get("spark", 0)
|
||||
history = user_state.get("history", [])
|
||||
|
||||
# Banner name
|
||||
banner_name = "Regular Recruitment"
|
||||
if banner_id and banner_id != "regular":
|
||||
for b in self._all_banners():
|
||||
if b["id"] == banner_id:
|
||||
rateups = ", ".join(b.get("rateups", [])) or "Standard Pool"
|
||||
banner_name = f"{b.get('gachaType', 'PickupGacha')} — {rateups}"
|
||||
break
|
||||
|
||||
# Recent pulls
|
||||
recent = []
|
||||
for sid in reversed(history[-5:]):
|
||||
s = db.get(sid)
|
||||
if s:
|
||||
recent.append(f"{'*' * s['StarGrade']} {s['Name']}")
|
||||
|
||||
embed = discord.Embed(
|
||||
title="Your Gacha Status",
|
||||
color=0x5BA0D0,
|
||||
)
|
||||
embed.add_field(name="Active Banner", value=banner_name, inline=False)
|
||||
embed.add_field(
|
||||
name="Recruitment Points", value=f"{spark}/{SPARK_TARGET}", inline=True
|
||||
)
|
||||
embed.add_field(
|
||||
name="Total Pulls", value=str(len(history)), inline=True
|
||||
)
|
||||
if recent:
|
||||
embed.add_field(
|
||||
name="Recent Pulls", value="\n".join(recent) or "None", inline=False
|
||||
)
|
||||
|
||||
await ctx.reply(embed=embed)
|
||||
|
||||
|
||||
async def setup(bot: commands.Bot) -> None:
|
||||
await bot.add_cog(BlueArchiveGacha(bot))
|
||||
@@ -0,0 +1,371 @@
|
||||
#this renders the gacha recruitment result screen using pillow, mimics the in-game look##
|
||||
"""Pillow-based compositor: renders an in-game-style gacha recruitment result screen."""
|
||||
######################################################################
|
||||
import asyncio
|
||||
import io
|
||||
import logging
|
||||
from pathlib import Path
|
||||
from typing import Optional
|
||||
|
||||
import aiohttp
|
||||
from PIL import Image, ImageDraw, ImageFont
|
||||
|
||||
from .data import db
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
# ── Layout constants (1920×1080 canvas) ────────────────────────────────────
|
||||
CANVAS_W, CANVAS_H = 1920, 1080
|
||||
CARD_W, CARD_H = 280, 390
|
||||
CARD_RADIUS = 10 # corner radius
|
||||
GAP_X, GAP_Y = 25, 20
|
||||
COLS, ROWS = 5, 2
|
||||
GRID_W = COLS * CARD_W + (COLS - 1) * GAP_X # 1500
|
||||
GRID_H = ROWS * CARD_H + (ROWS - 1) * GAP_Y # 800
|
||||
GRID_X = (CANVAS_W - GRID_W) // 2 # 210
|
||||
GRID_Y = 260 # below the header
|
||||
HEADER_Y = 120
|
||||
FOOTER_Y = GRID_Y + GRID_H + 50
|
||||
|
||||
STAR_BANNER_H = 36 # star rating strip at top of card
|
||||
NAME_STRIP_H = 42 # name/school strip at bottom
|
||||
PORTRAIT_TOP = STAR_BANNER_H + 4 # portrait starts below star banner
|
||||
PORTRAIT_H = CARD_H - PORTRAIT_TOP - NAME_STRIP_H - 4
|
||||
|
||||
# Rarity colours
|
||||
RARITY_COLORS = {
|
||||
3: (255, 200, 60), # gold
|
||||
2: (190, 130, 230), # purple
|
||||
1: (110, 170, 230), # blue
|
||||
}
|
||||
RARITY_BG = {
|
||||
3: (35, 28, 18),
|
||||
2: (28, 18, 38),
|
||||
1: (18, 22, 38),
|
||||
}
|
||||
|
||||
ASSETS_DIR = Path(__file__).parent / "assets"
|
||||
BG_PATH = ASSETS_DIR / "gacha_bg.png"
|
||||
|
||||
# ── Font helpers ───────────────────────────────────────────────────────────
|
||||
|
||||
def _get_font(size: int, bold: bool = False) -> ImageFont.FreeTypeFont:
|
||||
"""Try to load a nice font; fall back to default."""
|
||||
font_paths = [
|
||||
"C:/Windows/Fonts/segoeui.ttf",
|
||||
"C:/Windows/Fonts/segoeuib.ttf",
|
||||
"C:/Windows/Fonts/arial.ttf",
|
||||
"C:/Windows/Fonts/arialbd.ttf",
|
||||
"/usr/share/fonts/TTF/DejaVuSans.ttf",
|
||||
"/usr/share/fonts/TTF/DejaVuSans-Bold.ttf",
|
||||
]
|
||||
for fp in font_paths:
|
||||
if Path(fp).exists():
|
||||
try:
|
||||
return ImageFont.truetype(fp, size)
|
||||
except Exception:
|
||||
continue
|
||||
return ImageFont.load_default()
|
||||
|
||||
|
||||
HEADER_FONT = _get_font(52, bold=True)
|
||||
FOOTER_FONT = _get_font(18, bold=False)
|
||||
|
||||
|
||||
# ── Image fetching ─────────────────────────────────────────────────────────
|
||||
|
||||
async def _fetch_portrait(session: aiohttp.ClientSession, student: dict) -> Optional[Image.Image]:
|
||||
"""Download a student's face portrait.
|
||||
|
||||
Tries the wiki CDN first (252x204 face image). Falls back to SchaleDB
|
||||
full-body sprite with an upper-body crop on failure.
|
||||
"""
|
||||
student_id = student["Id"]
|
||||
|
||||
# 1. Try wiki face portrait
|
||||
wiki_url = db.wiki_portrait(student)
|
||||
try:
|
||||
async with session.get(wiki_url, timeout=aiohttp.ClientTimeout(total=10)) as resp:
|
||||
if resp.status == 200:
|
||||
data = await resp.read()
|
||||
return Image.open(io.BytesIO(data)).convert("RGBA")
|
||||
except Exception:
|
||||
log.debug("Wiki portrait failed for %s, trying SchaleDB fallback", student["Name"])
|
||||
|
||||
# 2. Fallback: SchaleDB full-body sprite with upper-body crop
|
||||
schale_url = db.schale_portrait(student_id)
|
||||
try:
|
||||
async with session.get(schale_url, timeout=aiohttp.ClientTimeout(total=10)) as resp:
|
||||
if resp.status == 200:
|
||||
data = await resp.read()
|
||||
img = Image.open(io.BytesIO(data)).convert("RGBA")
|
||||
# Crop top portion for face/upper-body (source is ~614x1024)
|
||||
p_w, p_h = img.size
|
||||
crop_h = int(p_w * 1.20)
|
||||
if crop_h < p_h:
|
||||
img = img.crop((0, 0, p_w, crop_h))
|
||||
return img
|
||||
except Exception:
|
||||
log.exception("Failed to fetch portrait for student %d", student_id)
|
||||
|
||||
return None
|
||||
|
||||
|
||||
# ── Drawing helpers ────────────────────────────────────────────────────────
|
||||
|
||||
def _rounded_rect(
|
||||
draw: ImageDraw.Draw,
|
||||
xy: tuple[int, int, int, int],
|
||||
radius: int,
|
||||
fill: Optional[tuple] = None,
|
||||
outline: Optional[tuple] = None,
|
||||
width: int = 3,
|
||||
) -> None:
|
||||
"""Draw a rounded rectangle."""
|
||||
draw.rounded_rectangle(xy, radius=radius, fill=fill, outline=outline, width=width)
|
||||
|
||||
|
||||
def _star_polygon(cx: int, cy: int, outer_r: int, inner_r: int) -> list[tuple[int, int]]:
|
||||
"""Return vertices for a 5-pointed star centered at (cx, cy)."""
|
||||
import math
|
||||
points = []
|
||||
for i in range(10):
|
||||
angle = math.pi / 2 + i * math.pi / 5 # start from top
|
||||
r = outer_r if i % 2 == 0 else inner_r
|
||||
x = cx + r * math.cos(angle)
|
||||
y = cy - r * math.sin(angle)
|
||||
points.append((int(x), int(y)))
|
||||
return points
|
||||
|
||||
|
||||
def _draw_star_icons(
|
||||
draw: ImageDraw.Draw,
|
||||
cx: int,
|
||||
cy: int,
|
||||
count: int,
|
||||
color: tuple,
|
||||
size: int = 7,
|
||||
) -> None:
|
||||
"""Draw <count> gold 5-pointed star icons horizontally centered at (cx, cy)."""
|
||||
outer = size
|
||||
inner = int(size * 0.38)
|
||||
spacing = int(size * 2.4)
|
||||
total_w = (count - 1) * spacing
|
||||
start_x = cx - total_w // 2
|
||||
for i in range(count):
|
||||
pts = _star_polygon(start_x + i * spacing, cy, outer, inner)
|
||||
# Shadow
|
||||
draw.polygon([(p[0] + 1, p[1] + 1) for p in pts], fill=(0, 0, 0, 100))
|
||||
draw.polygon(pts, fill=color)
|
||||
|
||||
|
||||
def _draw_rounded_rect(
|
||||
draw: ImageDraw.Draw,
|
||||
xy: tuple[int, int, int, int],
|
||||
radius: int,
|
||||
fill: Optional[tuple] = None,
|
||||
outline: Optional[tuple] = None,
|
||||
width: int = 3,
|
||||
) -> None:
|
||||
_rounded_rect(draw, xy, radius, fill, outline, width)
|
||||
|
||||
|
||||
# ── Main render ────────────────────────────────────────────────────────────
|
||||
|
||||
async def render_pull(
|
||||
pulls: list[dict],
|
||||
banner_name: str = "Regular Recruitment",
|
||||
spark_count: int = 0,
|
||||
) -> io.BytesIO:
|
||||
"""Render a 10-pull (or single-pull) result as a PNG image.
|
||||
|
||||
Args:
|
||||
pulls: List of student dicts from StudentDB (must have Id, Name, StarGrade).
|
||||
banner_name: Display name for the banner header.
|
||||
spark_count: Current spark/pity count to show in the footer.
|
||||
|
||||
Returns:
|
||||
BytesIO containing the rendered PNG image.
|
||||
"""
|
||||
# Load background
|
||||
if BG_PATH.exists():
|
||||
canvas = Image.open(BG_PATH).convert("RGBA")
|
||||
else:
|
||||
canvas = Image.new("RGBA", (CANVAS_W, CANVAS_H), (180, 226, 245))
|
||||
draw = ImageDraw.Draw(canvas)
|
||||
|
||||
# ── Header ──────────────────────────────────────────────────────────
|
||||
_draw_header(draw, banner_name)
|
||||
|
||||
# ── Footer / spark ──────────────────────────────────────────────────
|
||||
_draw_footer(draw, spark_count)
|
||||
|
||||
# ── Fetch all portraits ─────────────────────────────────────────────
|
||||
async with aiohttp.ClientSession() as session:
|
||||
portrait_tasks = [_fetch_portrait(session, p) for p in pulls]
|
||||
portraits = await asyncio.gather(*portrait_tasks)
|
||||
|
||||
# ── Draw cards in grid ──────────────────────────────────────────────
|
||||
for idx, (student, portrait) in enumerate(zip(pulls, portraits)):
|
||||
col = idx % COLS
|
||||
row = idx // COLS
|
||||
cx = GRID_X + col * (CARD_W + GAP_X)
|
||||
cy = GRID_Y + row * (CARD_H + GAP_Y)
|
||||
_draw_card(canvas, draw, cx, cy, student, portrait)
|
||||
|
||||
# ── Encode ──────────────────────────────────────────────────────────
|
||||
output = io.BytesIO()
|
||||
canvas.convert("RGB").save(output, format="PNG", optimize=True)
|
||||
output.seek(0)
|
||||
return output
|
||||
|
||||
|
||||
def _draw_header(draw: ImageDraw.Draw, banner_name: str) -> None:
|
||||
"""Draw the 'Recruitment Results' header at the top."""
|
||||
title = "Recruitment Results"
|
||||
tw = draw.textlength(title, font=HEADER_FONT)
|
||||
|
||||
# Banner name subtitle
|
||||
subtitle = banner_name
|
||||
sub_font = _get_font(26, bold=False)
|
||||
|
||||
# Shadow + text
|
||||
draw.text(((CANVAS_W - tw) / 2 + 2, HEADER_Y + 2), title, fill=(0, 0, 0, 100), font=HEADER_FONT)
|
||||
draw.text(((CANVAS_W - tw) / 2, HEADER_Y), title, fill=(255, 255, 255, 240), font=HEADER_FONT)
|
||||
|
||||
# Subtitle
|
||||
sw = draw.textlength(subtitle, font=sub_font)
|
||||
draw.text(((CANVAS_W - sw) / 2, HEADER_Y + 60), subtitle, fill=(255, 255, 255, 200), font=sub_font)
|
||||
|
||||
# Decorative line under header
|
||||
line_y = HEADER_Y + 100
|
||||
draw.line(
|
||||
[(GRID_X, line_y), (GRID_X + GRID_W, line_y)],
|
||||
fill=(255, 255, 255, 120),
|
||||
width=2,
|
||||
)
|
||||
|
||||
|
||||
def _draw_footer(draw: ImageDraw.Draw, spark_count: int) -> None:
|
||||
"""Draw spark counter at the bottom."""
|
||||
text = f"Recruitment Points: {spark_count} / 200"
|
||||
tw = draw.textlength(text, font=FOOTER_FONT)
|
||||
draw.text(
|
||||
((CANVAS_W - tw) / 2 + 1, FOOTER_Y + 1),
|
||||
text,
|
||||
fill=(0, 0, 0, 80),
|
||||
font=FOOTER_FONT,
|
||||
)
|
||||
draw.text(
|
||||
((CANVAS_W - tw) / 2, FOOTER_Y),
|
||||
text,
|
||||
fill=(255, 255, 255, 200),
|
||||
font=FOOTER_FONT,
|
||||
)
|
||||
|
||||
|
||||
def _draw_card(
|
||||
canvas: Image.Image,
|
||||
draw: ImageDraw.Draw,
|
||||
x: int,
|
||||
y: int,
|
||||
student: dict,
|
||||
portrait: Optional[Image.Image],
|
||||
) -> None:
|
||||
"""Draw a single recruitment result card at (x, y)."""
|
||||
rarity = student["StarGrade"]
|
||||
color = RARITY_COLORS.get(rarity, (150, 150, 150))
|
||||
bg = RARITY_BG.get(rarity, (20, 20, 20))
|
||||
|
||||
# Card background with rounded corners
|
||||
_draw_rounded_rect(draw, (x, y, x + CARD_W, y + CARD_H), radius=CARD_RADIUS, fill=bg + (255,))
|
||||
# Card border
|
||||
_draw_rounded_rect(
|
||||
draw, (x, y, x + CARD_W, y + CARD_H), radius=CARD_RADIUS, outline=color, width=2
|
||||
)
|
||||
|
||||
# ── Star banner strip at top ────────────────────────────────────────
|
||||
banner_top = y + 1
|
||||
banner_bottom = y + STAR_BANNER_H
|
||||
# Semi-transparent dark strip
|
||||
_draw_rounded_rect(
|
||||
draw,
|
||||
(x + 3, banner_top, x + CARD_W - 3, banner_bottom),
|
||||
radius=CARD_RADIUS - 2,
|
||||
fill=(0, 0, 0, 80),
|
||||
)
|
||||
# Draw star icons centered in the banner
|
||||
_draw_star_icons(
|
||||
draw,
|
||||
x + CARD_W // 2,
|
||||
y + STAR_BANNER_H // 2,
|
||||
rarity,
|
||||
color,
|
||||
size=8,
|
||||
)
|
||||
|
||||
# ── Portrait area ───────────────────────────────────────────────────
|
||||
px = x + 6
|
||||
py = y + PORTRAIT_TOP
|
||||
pw = CARD_W - 12
|
||||
ph = PORTRAIT_H
|
||||
|
||||
if portrait:
|
||||
portrait = portrait.copy()
|
||||
p_w, p_h = portrait.size
|
||||
scale = min(pw / p_w, ph / p_h)
|
||||
new_w, new_h = int(p_w * scale), int(p_h * scale)
|
||||
portrait = portrait.resize((new_w, new_h), Image.LANCZOS)
|
||||
pox = px + (pw - new_w) // 2
|
||||
poy = py + (ph - new_h) // 2
|
||||
canvas.paste(portrait, (pox, poy), portrait if portrait.mode == "RGBA" else None)
|
||||
else:
|
||||
_draw_rounded_rect(draw, (px, py, px + pw, py + ph), radius=6, fill=(30, 30, 40, 180))
|
||||
ph_font = _get_font(16)
|
||||
msg = "No Image"
|
||||
mw = draw.textlength(msg, font=ph_font)
|
||||
draw.text((px + (pw - mw) / 2, py + ph / 2 - 10), msg, fill=(150, 150, 150), font=ph_font)
|
||||
|
||||
# ── Name strip at bottom ────────────────────────────────────────────
|
||||
name_y = y + CARD_H - NAME_STRIP_H + 2
|
||||
_draw_rounded_rect(
|
||||
draw,
|
||||
(x + 3, name_y, x + CARD_W - 3, y + CARD_H - 3),
|
||||
radius=CARD_RADIUS - 3,
|
||||
fill=(0, 0, 0, 150),
|
||||
)
|
||||
|
||||
# Student name
|
||||
name = student["Name"]
|
||||
name_font = _get_font(20, bold=True)
|
||||
nw = draw.textlength(name, font=name_font)
|
||||
draw.text(
|
||||
(x + (CARD_W - nw) / 2 + 1, name_y + 2),
|
||||
name,
|
||||
fill=(0, 0, 0),
|
||||
font=name_font,
|
||||
)
|
||||
draw.text(
|
||||
(x + (CARD_W - nw) / 2, name_y + 1),
|
||||
name,
|
||||
fill=(255, 255, 255),
|
||||
font=name_font,
|
||||
)
|
||||
|
||||
# School label
|
||||
school = student.get("School", "")
|
||||
if school:
|
||||
sch_font = _get_font(14)
|
||||
sw2 = draw.textlength(school, font=sch_font)
|
||||
draw.text(
|
||||
(x + (CARD_W - sw2) / 2 + 1, name_y + 23),
|
||||
school,
|
||||
fill=(0, 0, 0),
|
||||
font=sch_font,
|
||||
)
|
||||
draw.text(
|
||||
(x + (CARD_W - sw2) / 2, name_y + 22),
|
||||
school,
|
||||
fill=color + (200,),
|
||||
font=sch_font,
|
||||
)
|
||||
Reference in new issue
Block a user