Skirmish: Making the game your own

/// Advances one tick. `commands` may hold anything; only those stamped with
/// the current tick are applied, in the order given (the server's order).
public void step(List<Command> commands) {
    if (isOver()) {
        return;
    }
    events.clear();
    if (commands != null) {
        for (int i = 0; i < commands.size(); i++) {
            Command c = commands.get(i);
            if (c.tick == tick) {
                apply(c);
            }
        }
    }
    runWaves();
    regenElixir();
    int count = units.size();
    for (int i = 0; i < count; i++) {
        Unit u = units.get(i);
        if (u.hp > 0) {
            update(u);
        }
    }
    separate();
    removeDead();
    tick++;
    checkEnd();
}

add(new CardDef("squire", "Squire", CardDef.TROOP, 3)
        .hp(1450).damage(160).hitTicks(24).range(700).speed(45).radius(500));

public final class Models {
    /// How one card looks on the field.
    public static final class Look {
        public final String model;
        /// Height in tiles for a character; footprint width in tiles for a
        /// building.
        public final float size;
        public final String attack;
        public final float hover;
        public final int tint;
        public final String idle;
        public final String run;
        public final String death;

        Look(String model, float size, String attack, float hover, int tint) {
            this(model, size, attack, hover, tint, "Idle", "Running_A", "Death_A");
        }

        Look(String model, float size, String attack, float hover, int tint, String idle, String run,
                String death) {
            this.model = model;
            this.size = size;
            this.attack = attack;
            this.hover = hover;
            this.tint = tint;
            this.idle = idle;
            this.run = run;
            this.death = death;
        }
    }

    private static final Map<String, Look> LOOKS = new HashMap<String, Look>();
    private static final Map<String, GltfScene> SCENES = new HashMap<String, GltfScene>();

    static {
        look("squire", "knight", 1.96f, "1H_Melee_Attack_Chop", 0f, 0xffffffff);
        look("twin-archers", "rogue_hooded", 1.67f, "1H_Ranged_Shoot", 0f, 0xffffffff);
        look("ogre", "barbarian", 3.04f, "2H_Melee_Attack_Chop", 0f, 0xffffffff);
        look("bat-swarm", "skeleton_rogue", 1.16f, "1H_Melee_Attack_Chop", 1.6f, 0xffb8c8ff);
        look("sharpshooter", "rogue", 1.89f, "2H_Ranged_Shoot", 0f, 0xffffffff);
        look("spearmen", "skeleton_warrior", 1.74f, "1H_Melee_Attack_Chop", 0f, 0xffffffff);
        look("drake", "mage", 2.03f, "Spellcast_Shoot", 1.8f, 0xffffffff);
        look("imp", "skeleton_minion", 1.38f, "Unarmed_Melee_Attack_Punch_A", 0f, 0xffffffff);
        look("imp-den", "crypt", 3.77f, null, 0f, 0xffffffff);
    }

    private Models() {
    }

    private static void look(String card, String model, float size, String attack, float hover, int tint) {
        LOOKS.put(card, new Look(model, size, attack, hover, tint));
    }

    /// The look of `card`, or null for a spell or a tower (drawn by the view).
    public static Look of(String card) {
        return LOOKS.get(card);
    }

    /// The look of a card from a Forge pack: its own model, bundled or
    /// uploaded, its size and tint, and the clips its author mapped. A card
    /// with no model of its own falls back to a bundled one by kind.
    public static Look of(CardDef card) {
        Look builtin = LOOKS.get(card.id);
        if (builtin != null || card.kind == CardDef.SPELL || card.kind == CardDef.TOWER) {
            return builtin;
        }
        String model = card.model();
        if (model == null || model.length() == 0) {
            model = card.kind == CardDef.BUILDING ? "crypt" : card.isFlying() ? "skeleton_rogue" : "knight";
        }
        float size = (card.kind == CardDef.BUILDING ? 3.5f : 1.9f) * Math.max(25, card.scalePercent()) / 100f;
        int tint = card.tint() < 0 ? 0xffffffff : 0xff000000 | card.tint();
        String clips = card.clips();
        String attack = GlbInspector.clip(clips, "attack");
        if (attack == null && card.kind != CardDef.BUILDING) {
            attack = card.range() > 1500 ? "1H_Ranged_Shoot" : "1H_Melee_Attack_Chop";
        }
        return new Look(model, size, attack, card.isFlying() ? 1.6f : 0f, tint,
                orElse(GlbInspector.clip(clips, "idle"), "Idle"), orElse(GlbInspector.clip(clips, "run"), "Running_A"),
                orElse(GlbInspector.clip(clips, "death"), "Death_A"));
    }

    private static String orElse(String v, String fallback) {
        return v == null ? fallback : v;
    }

    /// Whether `name` is one of the models that ship with the game.
    public static boolean isBundled(String name) {
        return CN.getResourceAsStream("/model_" + name + ".glb") != null;
    }

    /// The parsed model `name`, loaded once: `/model_<name>.glb` for a bundled
    /// one, or an uploaded file, `asset:<sha256>`, from [ForgeFiles].
    public static synchronized GltfScene scene(String name) {
        GltfScene s = SCENES.get(name);
        if (s == null) {
            InputStream in = name.startsWith("asset:") ? ForgeFiles.open(name.substring(6))
                    : CN.getResourceAsStream("/model_" + name + ".glb");
            if (in == null) {
                throw new IllegalStateException("missing model " + name);
            }
            try {
                s = GltfLoader.loadScene(in);
            } catch (java.io.IOException err) {
                Log.e(err);
                throw new IllegalStateException("unreadable model " + name);
            }
            SCENES.put(name, s);
        }
        return s;
    }
}

final class MatchRoom {
    /// Plays a seat may make in [#FLOOD_WINDOW] ticks before the rest are dropped.
    static final int FLOOD_LIMIT = 6;
    static final int FLOOD_WINDOW = 20;

    final String id;
    final Match match;
    final Seat[] seats;
    final Bot bot;
    final List<Command> log = new ArrayList<Command>();
    final List<WebSocketSession> spectators = new ArrayList<WebSocketSession>();
    final long startedAt;
    /// Index into [#log] of the first command not yet sent.
    int sent;
    int lastSentTick = -1;
    int forfeit = -1;
    final java.util.Map<Integer, Long> hashes = new java.util.HashMap<Integer, Long>();

    MatchRoom(String id, long seed, Seat a, Seat b, long now) {
        this.id = id;
        this.seats = new Seat[] {a, b};
        this.match = new Match(seed, a.deck, b.deck);
        this.bot = b.isBot() ? new Bot(1, seed ^ 0x1234L) : null;
        this.startedAt = now;
    }

    int seatOf(String username) {
        for (int i = 0; i < 2; i++) {
            if (seats[i].username.equals(username)) {
                return i;
            }
        }
        return -1;
    }

    /// Accepts a play intent from `player`. Answers false when it was dropped.
    boolean intent(int player, String card, int x, int y) {
        if (match.isOver()) {
            return false;
        }
        Seat seat = seats[player];
        int now = match.tick();
        int inWindow = 0;
        for (int i = 0; i < seat.recentCount; i++) {
            if (now - seat.recent[i] < FLOOD_WINDOW) {
                inWindow++;
            }
        }
        if (inWindow >= FLOOD_LIMIT) {
            seat.floods++;
            return false;
        }
        seat.recent[seat.recentCount % seat.recent.length] = now;
        seat.recentCount = Math.min(seat.recentCount + 1, seat.recent.length);
        // A cheap early answer; the rules check again when the command executes.
        if (!match.canPlay(player, card, x, y)) {
            seat.rejected++;
            return false;
        }
        log.add(new Command(now + GameProtocol.INPUT_DELAY, player, card, x, y));
        return true;
    }

    /// Advances one tick, letting the bot decide first.
    void step() {
        if (bot != null) {
            Command c = bot.decide(match, GameProtocol.INPUT_DELAY);
            if (c != null) {
                log.add(c);
            }
        }
        match.step(log);
        if (match.tick() % GameProtocol.HASH_EVERY == 0) {
            hashes.put(Integer.valueOf(match.tick()), Long.valueOf(match.stateHash()));
            hashes.remove(Integer.valueOf(match.tick() - 10 * GameProtocol.HASH_EVERY));
        }
    }

    /// The result: [Match#result], or the side that did not leave.
    int result() {
        return forfeit >= 0 ? 1 - forfeit : match.result();
    }

    boolean isOver() {
        return forfeit >= 0 || match.isOver();
    }

    Replay replay() {
        return new Replay(match.seed(), seats[0].deck, seats[1].deck, log);
    }
}

public final class OnlineDriver extends Driver {
    /// What the battle screen wants to hear besides the ticks.
    public interface Listener {
        void emote(int seat, String id);

        void ended(int result, int crowns0, int crowns1, int trophies, int coins, String matchId);

        void lost();
    }

    private final GameLink link;
    private final boolean spectator;
    private Listener listener;
    private String matchId;
    private String[] names = {"", ""};
    private int allowed;

    public OnlineDriver(GameLink link, Map<String, Object> start, boolean spectator) {
        this.link = link;
        this.spectator = spectator;
        restart(start);
    }

    public void setListener(Listener listener) {
        this.listener = listener;
    }

    public String matchId() {
        return matchId;
    }

    /// A `start` message: the first one, or the server's answer to a hash
    /// that did not match. Either way the match is rebuilt from its log.
    private void restart(Map<String, Object> m) {
        matchId = GameLink.text(m, "match");
        me = spectator ? 0 : GameLink.number(m, "you");
        names = new String[] {GameLink.text(m, "name0"), GameLink.text(m, "name1")};
        match = new Match(Long.parseLong(GameLink.text(m, "seed")),
                split(GameLink.text(m, "deck0"), ','), split(GameLink.text(m, "deck1"), ','));
        log.clear();
        append(GameLink.text(m, "log"));
        allowed = GameLink.number(m, "tick");
        // Catch up at once to where the server already is.
        while (match.tick() < allowed && !match.isOver()) {
            match.step(log);
        }
    }

    /// Everything the server sends during a match comes through here.
    public void message(Map<String, Object> m) {
        String type = GameLink.text(m, "type");
        if (GameProtocol.TICKS.equals(type)) {
            append(GameLink.text(m, "c"));
            allowed = Math.max(allowed, GameLink.number(m, "t"));
        } else if (GameProtocol.START.equals(type)) {
            restart(m);
        } else if (GameProtocol.EMOTE.equals(type) && listener != null) {
            listener.emote(GameLink.number(m, "player"), GameLink.text(m, "id"));
        } else if (GameProtocol.END.equals(type) && listener != null) {
            listener.ended(GameLink.number(m, "result"), GameLink.number(m, "crowns0"),
                    GameLink.number(m, "crowns1"), GameLink.number(m, "trophies"),
                    GameLink.number(m, "coins"), GameLink.text(m, "match"));
        } else if (GameProtocol.KICKED.equals(type) && listener != null) {
            listener.lost();
        }
    }

    @Override
    public boolean canStep() {
        return match.tick() < allowed && !match.isOver();
    }

    @Override
    public void step() {
        super.step();
        if (!spectator && match.tick() % GameProtocol.HASH_EVERY == 0) {
            link.send("{\"type\":\"sync\",\"t\":" + match.tick() + ",\"h\":\""
                    + Match.hex(match.stateHash()) + "\"}");
        }
    }

    /// Only asks. The play appears when the server stamps it and sends it
    /// back -- to both players at once.
    @Override
    public void play(String card, int x, int y) {
        if (!spectator && match.canPlay(me, card, x, y)) {
            link.send("{\"type\":\"play\",\"card\":\"" + card + "\",\"x\":" + x + ",\"y\":" + y + "}");
        }
    }

    @Override
    public boolean interactive() {
        return !spectator;
    }

    public void emote(String id) {
        link.send("{\"type\":\"emote\",\"id\":\"" + id + "\"}");
    }

    public void leave() {
        link.send("{\"type\":\"leave\"}");
    }

    @Override
    public String name(int seat) {
        if (!spectator && seat == me) {
            return "You";
        }
        return names[seat];
    }

    @Override
    public void dispose() {
        link.close();
    }

    private void append(String encoded) {
        for (String c : split(encoded, ';')) {
            if (c.length() > 0) {
                log.add(Command.decode(c));
            }
        }
    }

    /// `String.split` takes a regular expression and is missing on some
    /// targets; this takes one character.
    static String[] split(String s, char sep) {
        if (s == null || s.length() == 0) {
            return new String[0];
        }
        int n = 1;
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) == sep) {
                n++;
            }
        }
        String[] out = new String[n];
        int from = 0;
        int k = 0;
        for (int i = 0; i <= s.length(); i++) {
            if (i == s.length() || s.charAt(i) == sep) {
                out[k++] = s.substring(from, i);
                from = i + 1;
            }
        }
        return out;
    }
}

/// The finishing move: once the match is decided the camera leaves its
/// fixed battle view, swings around the field and comes down low beside
/// the fallen king tower, so the last blow is seen from the ground. The
/// rules are already over, so this is purely the renderer's -- a replay
/// or a spectator sees the same sweep.
private void startFinale(Match m) {
    previewFinale(m.result());
}

/// Runs the sweep toward `winner`'s victory (or a draw) without the match
/// being over: the screenshot tests use it to photograph the finale.
public void previewFinale(int winner) {
    int loser = winner < 0 ? -1 : 1 - winner;
    if (loser < 0) {
        // A draw: look at the bridge between the two sides.
        finaleX = 0f;
        finaleZ = 0f;
    } else {
        Arena.Tower king = arena().king(loser);
        finaleX = wx(king.x, king.y);
        finaleZ = wz(king.x, king.y);
    }
    finale = 0f;
}

private void finale(float dt) {
    finale = Math.min(FINALE_SECONDS, finale + dt);
    float t = finale / FINALE_SECONDS;
    // Ease in and out, so the sweep starts and settles without a jolt.
    float e = t * t * (3f - 2f * t);
    // Orbit from straight behind the player's side to a three-quarter view
    // beside the tower, dropping from the battle height to eye level.
    double angle = Math.toRadians(e * 125f);
    float radius = 42f - e * 22f;
    float height = 33f - e * 24f;
    float cx = finaleX * e;
    float cz = 1.6f + (finaleZ - 1.6f) * e;
    float ex = cx + (float) Math.sin(angle) * radius;
    float ez = cz + (float) Math.cos(angle) * radius * (30f / 42f + e * (1f - 30f / 42f))
            - 1.6f * (1f - e);
    GameCamera cam = getCamera();
    cam.setPosition(ex, height, ez);
    cam.setTarget(cx, 1.6f * e, cz);
}

/// True while the finishing sweep still has frames to show.
public boolean finaleRunning() {
    return finale >= 0f && finale < FINALE_SECONDS;
}

@Component
public class Progression {
    /// Chests wait in slots; a win with every slot full earns none.
    public static final int CHEST_SLOTS = 4;
    public static final int WIN_XP = 40;
    public static final int DRAW_XP = 20;
    public static final int LOSS_XP = 15;
    public static final int CROWN_XP = 5;
    public static final int TUTORIAL_XP = 100;
    public static final int TUTORIAL_COINS = 100;
    public static final int LEVEL_UP_COINS = 60;
    public static final int LEVEL_UP_GEMS = 5;

    private final ProgressRepository progress;
    private final ProfileRepository profiles;

    public Progression(ProgressRepository progress, ProfileRepository profiles) {
        this.progress = progress;
        this.profiles = profiles;
    }

    /// Counts a finished battle for one side. Called from inside the
    /// transaction that records the match, with the profile it is about to
    /// save, so the coins and gems this grants are saved with it.
    public RewardDto afterMatch(Profile p, boolean won, boolean draw, int crowns, int cards, int spells)
            throws IOException {
        Progress g = load(p.getUsername());
        int[] before = stats(g);
        g.setMatches(g.getMatches() + 1);
        g.setCards(g.getCards() + cards);
        g.setSpells(g.getSpells() + spells);
        g.setTowers(g.getTowers() + crowns);
        int chests = 0;
        if (won) {
            g.setWins(g.getWins() + 1);
            g.setStreak(g.getStreak() + 1);
            g.setBestStreak(Math.max(g.getBestStreak(), g.getStreak()));
            if (g.getChests() < CHEST_SLOTS) {
                g.setChests(g.getChests() + 1);
                chests = 1;
            }
        } else if (!draw) {
            g.setStreak(0);
        }
        int[] after = stats(g);
        Goals.Goal[] quests = Goals.questsFor(p.getUsername(), g.getQuestDay());
        for (int i = 0; i < 3; i++) {
            int gained = after[quests[i].stat] - before[quests[i].stat];
            setQuest(g, i, Math.min(quests[i].goal, quest(g, i) + gained));
        }
        int xp = (won ? WIN_XP : draw ? DRAW_XP : LOSS_XP) + CROWN_XP * crowns;
        Reward r = new Reward(won ? "Victory!" : draw ? "Draw" : "Defeat");
        r.chests = chests;
        r.xp(g, p, xp);
        unlock(g, p, r);
        progress.save(g);
        return r.dto(g);
    }

    @Transactional(rollbackFor = IOException.class)
    public ProgressDto view(String username) throws IOException {
        Profile p = profile(username);
        // Reading never creates the row: the first battle's result, recorded
        // on the match ticker's thread, may be inserting it at this moment,
        // and a second insert of the same key fails (MySQL waits on the
        // uncommitted row, then reports a duplicate).
        boolean stored = progress.findById(username) != null;
        Progress g = stored ? load(username) : fresh(username);
        if (stored) {
            progress.save(g);
        }
        return dto(g, p);
    }

    @Transactional(rollbackFor = IOException.class)
    public RewardDto claim(String username, String questId) throws IOException {
        Profile p = profile(username);
        Progress g = load(username);
        Goals.Goal[] quests = Goals.questsFor(username, g.getQuestDay());
        int index = -1;
        for (int i = 0; i < 3; i++) {
            if (quests[i].id.equals(questId)) {
                index = i;
            }
        }
        if (index < 0) {
            throw new ResponseStatusException(404, "That is not one of today's quests");
        }
        if ((g.getClaimed() & (1 << index)) != 0) {
            throw new ResponseStatusException(409, "Already claimed");
        }
        Goals.Goal q = quests[index];
        if (quest(g, index) < q.goal) {
            throw new ResponseStatusException(409, "Not finished yet");
        }
        g.setClaimed(g.getClaimed() | (1 << index));
        Reward r = new Reward(q.title);
        r.coins(p, q.coins);
        r.xp(g, p, q.xp);
        unlock(g, p, r);
        progress.save(g);
        profiles.save(p);
        return r.dto(g);
    }

    /// Opens the oldest chest. What is inside grows with the level; every
    /// third chest also holds gems.
    @Transactional(rollbackFor = IOException.class)
    public RewardDto openChest(String username) throws IOException {
        Profile p = profile(username);
        Progress g = load(username);
        if (g.getChests() <= 0) {
            throw new ResponseStatusException(409, "No chest to open");
        }
        int level = Goals.levelOf(g.getXp());
        g.setChests(g.getChests() - 1);
        g.setChestsOpened(g.getChestsOpened() + 1);
        boolean rare = g.getChestsOpened() % 3 == 0;
        Reward r = new Reward(rare ? "Gold Chest" : "Wooden Chest");
        r.coins(p, 40 + 15 * level + (rare ? 40 : 0));
        if (rare) {
            r.gems(p, 4 + level);
        }
        r.xp(g, p, 20);
        unlock(g, p, r);
        progress.save(g);
        profiles.save(p);
        return r.dto(g);
    }

    /// The training battle pays once.
    @Transactional(rollbackFor = IOException.class)
    public RewardDto tutorialDone(String username) throws IOException {
        Profile p = profile(username);
        Progress g = load(username);
        Reward r = new Reward("Training complete");
        if (!g.isTutorialDone()) {
            g.setTutorialDone(true);
            r.coins(p, TUTORIAL_COINS);
            if (g.getChests() < CHEST_SLOTS) {
                g.setChests(g.getChests() + 1);
                r.chests = 1;
            }
            r.xp(g, p, TUTORIAL_XP);
            unlock(g, p, r);
            progress.save(g);
            profiles.save(p);
        }
        return r.dto(g);
    }

    /// Pays for stars won in a Forge mission. The caller has already verified
    /// the result and decided the amounts; this only books them, so experience
    /// still levels the player up and reaches achievements as it does anywhere.
    @Transactional(rollbackFor = IOException.class)
    public RewardDto missionReward(String username, String title, int coins, int xp) throws IOException {
        Profile p = profile(username);
        Progress g = load(username);
        Reward r = new Reward(title);
        if (coins > 0 || xp > 0) {
            r.coins(p, coins);
            r.xp(g, p, xp);
            unlock(g, p, r);
            progress.save(g);
            profiles.save(p);
        }
        return r.dto(g);
    }

    /// Gives a demo account some history -- a few levels, two chests, a
    /// finished quest waiting to be claimed -- so the development server's
    /// home screen shows what a regular player sees, and the tutorial does not
    /// start on every sign-in.
    @Transactional(rollbackFor = IOException.class)
    public void seedDemo(String username) throws IOException {
        Progress g = load(username);
        if (g.getMatches() > 0) {
            return;
        }
        g.setTutorialDone(true);
        g.setXp(420);
        g.setChests(2);
        g.setChestsOpened(1);
        g.setMatches(7);
        g.setWins(4);
        g.setCards(62);
        g.setSpells(9);
        g.setTowers(6);
        g.setStreak(2);
        g.setBestStreak(2);
        Goals.Goal[] today = Goals.questsFor(username, g.getQuestDay());
        g.setQuest0(today[0].goal);
        g.setQuest1(today[1].goal / 2);
        // Unlocked for what the counters say, without paying for it: the
        // profile here is a throwaway, never saved.
        Profile scratch = new Profile();
        unlock(g, scratch, new Reward(""));
        g.setXp(420);
        progress.save(g);
    }

    private Profile profile(String username) throws IOException {
        Profile p = profiles.findById(username);
        if (p == null) {
            throw new ResponseStatusException(404, "No such player");
        }
        return p;
    }

    /// The player's row, created on first use, with today's quests reset when
    /// the day has turned.
    private Progress load(String username) throws IOException {
        Progress g = progress.findById(username);
        long today = Clock.dayOf(Clock.now());
        if (g == null) {
            g = fresh(username);
            progress.insert(g);
        }
        if (g.getQuestDay() != today) {
            g.setQuestDay(today);
            g.setQuest0(0);
            g.setQuest1(0);
            g.setQuest2(0);
            g.setClaimed(0);
        }
        return g;
    }

    private static Progress fresh(String username) {
        Progress g = new Progress();
        g.setUsername(username);
        g.setQuestDay(Clock.dayOf(Clock.now()));
        return g;
    }

    private static int[] stats(Progress g) {
        return new int[] {g.getWins(), g.getMatches(), g.getCards(), g.getSpells(), g.getTowers(),
            g.getBestStreak(), g.isTutorialDone() ? 1 : 0, Goals.levelOf(g.getXp())};
    }

    private static int quest(Progress g, int i) {
        return i == 0 ? g.getQuest0() : i == 1 ? g.getQuest1() : g.getQuest2();
    }

    private static void setQuest(Progress g, int i, int value) {
        if (i == 0) {
            g.setQuest0(value);
        } else if (i == 1) {
            g.setQuest1(value);
        } else {
            g.setQuest2(value);
        }
    }

    private static boolean unlocked(Progress g, String id) {
        return ("," + g.getAchievements() + ",").indexOf("," + id + ",") >= 0;
    }

    /// Unlocks every achievement now reached. Unlocking pays experience, which
    /// can level up, which can reach the level achievement: hence the loop.
    private static void unlock(Progress g, Profile p, Reward r) {
        boolean more = true;
        while (more) {
            more = false;
            int[] s = stats(g);
            for (Goals.Goal a : Goals.ACHIEVEMENTS) {
                if (!unlocked(g, a.id) && s[a.stat] >= a.goal) {
                    g.setAchievements(g.getAchievements().isEmpty() ? a.id : g.getAchievements() + "," + a.id);
                    r.unlocked.add(a.title);
                    r.gems(p, a.gems);
                    r.xp(g, p, a.xp);
                    more = true;
                }
            }
        }
    }

    private static ProgressDto dto(Progress g, Profile p) {
        int level = Goals.levelOf(g.getXp());
        Goals.Goal[] today = Goals.questsFor(g.getUsername(), g.getQuestDay());
        List<QuestDto> quests = new ArrayList<>();
        for (int i = 0; i < 3; i++) {
            Goals.Goal q = today[i];
            quests.add(new QuestDto(q.id, q.title, quest(g, i), q.goal, q.coins, q.xp,
                    (g.getClaimed() & (1 << i)) != 0));
        }
        int[] s = stats(g);
        List<AchievementDto> achievements = new ArrayList<>();
        for (Goals.Goal a : Goals.ACHIEVEMENTS) {
            achievements.add(new AchievementDto(a.id, a.title, a.detail, Math.min(a.goal, s[a.stat]), a.goal,
                    unlocked(g, a.id)));
        }
        return new ProgressDto(level, g.getXp(), Goals.levelStart(level), Goals.levelStart(level + 1),
                g.isTutorialDone(), g.getChests(), p.getCoins(), p.getGems(), g.getStreak(), g.getWins(),
                quests, achievements);
    }

    /// A reward being put together; granting through it keeps the popup and
    /// the balances in step.
    private static final class Reward {
        final String title;
        final List<String> unlocked = new ArrayList<>();
        int coins;
        int gems;
        int xp;
        int chests;
        boolean levelUp;

        Reward(String title) {
            this.title = title;
        }

        void coins(Profile p, int n) {
            p.setCoins(p.getCoins() + n);
            coins += n;
        }

        void gems(Profile p, int n) {
            p.setGems(p.getGems() + n);
            gems += n;
        }

        /// Adds experience; each level gained pays coins, gems and a chest.
        void xp(Progress g, Profile p, int n) {
            int from = Goals.levelOf(g.getXp());
            g.setXp(g.getXp() + n);
            xp += n;
            int to = Goals.levelOf(g.getXp());
            for (int l = from; l < to; l++) {
                levelUp = true;
                coins(p, LEVEL_UP_COINS);
                gems(p, LEVEL_UP_GEMS);
                if (g.getChests() < CHEST_SLOTS) {
                    g.setChests(g.getChests() + 1);
                    chests++;
                }
            }
        }

        RewardDto dto(Progress g) {
            return new RewardDto(title, coins, gems, xp, chests, Goals.levelOf(g.getXp()), levelUp, unlocked);
        }
    }
}

public interface ReceiptValidator {
    /// The store's transaction id when `receipt` proves a purchase of `sku`, or
    /// null when it does not.
    String verify(String store, String sku, String transactionId, String receipt) throws IOException;
}

/// `skirmish.iap.provider` is one of:
///
/// - `store`: receipts are checked with Apple (`skirmish.iap.apple.secret`)
///   and Google Play (`skirmish.iap.google.package` and
///   `skirmish.iap.google.token`). A store with no settings refuses its
///   receipts; the other keeps working.
/// - `simulated`: every receipt is accepted, on a development profile only.
///
/// Unset, it is `simulated` on a development profile and `store` otherwise.
@Bean
public ReceiptValidator receipts(Config config,
        @Value("${skirmish.iap.provider:}") String chosen,
        @Value("${skirmish.iap.apple.secret:}") String appleSecret,
        @Value("${skirmish.iap.google.package:}") String googlePackage,
        @Value("${skirmish.iap.google.token:}") String googleToken) {
    String kind = chosen.trim().length() > 0 ? chosen.trim()
            : config.isDevelopmentProfile() ? "simulated" : "store";
    if ("simulated".equalsIgnoreCase(kind)) {
        if (!config.isDevelopmentProfile()) {
            return new MisconfiguredReceipts("skirmish.iap.provider=simulated grants every "
                    + "purchase for free and is refused on the '" + config.getProfile()
                    + "' profile; set it to store");
        }
        return new SimulatedReceipts();
    }
    if (!"store".equalsIgnoreCase(kind)) {
        return new MisconfiguredReceipts("skirmish.iap.provider is '" + kind
                + "', which is neither store nor simulated");
    }
    if (appleSecret.trim().length() == 0 && (googlePackage.trim().length() == 0
            || googleToken.trim().length() == 0)) {
        return new MisconfiguredReceipts("in-app purchases are not configured; set "
                + "skirmish.iap.apple.secret, or skirmish.iap.google.package and "
                + "skirmish.iap.google.token");
    }
    return new StoreReceipts(appleSecret.trim(), googlePackage.trim(), googleToken.trim());
}

/// Google's published test ad units. They always fill, never pay, and are
/// safe to click; replace them with your own AdMob units before release.
public static final String REWARDED_AD_UNIT = "ca-app-pub-3940256099942544/5224354917";
public static final String INTERSTITIAL_AD_UNIT = "ca-app-pub-3940256099942544/1033173712";
public static final String BANNER_AD_UNIT = "ca-app-pub-3940256099942544/6300978111";
/// The store products, as configured in App Store Connect and the Play
/// Console. The server's `Catalog` names the same ones.
public static final String SKU_GEMS_80 = "skirmish.gems_80";
public static final String SKU_GEMS_500 = "skirmish.gems_500";
public static final String SKU_ROYAL_PASS = "skirmish.royal_pass";

public final class Ads {
    private static final int INTERSTITIAL_EVERY = 3;
    private static int battlesSinceAd;

    private Ads() {
    }

    public static void start() {
        if (AdManager.getProvider() != null) {
            AdManager.initialize(new AdConfig().testMode(true), ready -> { });
        }
    }

    /// Plays a rewarded ad and runs `granted` once the network says it was
    /// watched to the end.
    public static void rewarded(final Runnable granted, final Runnable unavailable) {
        Telemetry.adWatched("rewarded_offer");
        if (!AdManager.isInitialized() || !AdManager.isSupported(AdFormat.REWARDED)) {
            standIn(granted);
            return;
        }
        final RewardedAd ad = new RewardedAd(AppConfig.REWARDED_AD_UNIT);
        // Server-side verification: the network calls the game's server with
        // this user id, so a reward could be granted there and nowhere else.
        String who = Session.user() == null ? "" : Session.user().username();
        ad.setServerSideVerificationOptions(new ServerSideVerificationOptions(who, "coins"));
        ad.setAdListener(new AdListener() {
            @Override
            public void onLoaded() {
                ad.show(reward -> CN.callSerially(granted));
            }

            @Override
            public void onFailedToLoad(AdError error) {
                CN.callSerially(unavailable);
            }
        });
        ad.load();
    }

    /// Called after every battle; shows an interstitial every few.
    public static void betweenBattles(boolean adFree) {
        battlesSinceAd++;
        if (adFree || battlesSinceAd < INTERSTITIAL_EVERY || !AdManager.isInitialized()
                || !AdManager.isSupported(AdFormat.INTERSTITIAL)) {
            return;
        }
        battlesSinceAd = 0;
        final InterstitialAd ad = new InterstitialAd(AppConfig.INTERSTITIAL_AD_UNIT);
        ad.setAdListener(new AdListener() {
            @Override
            public void onLoaded() {
                ad.show();
            }
        });
        ad.load();
    }

    /// A banner for the home screen, or null where there is no network.
    public static Component banner(boolean adFree) {
        if (adFree || !AdManager.isInitialized() || !AdManager.isSupported(AdFormat.BANNER)) {
            return null;
        }
        BannerAd banner = new BannerAd(AppConfig.BANNER_AD_UNIT);
        banner.load();
        return banner;
    }

    private static void standIn(final Runnable granted) {
        Dialog d = new Dialog("Sponsored", new com.codename1.ui.layouts.BorderLayout());
        d.setUIID("AdDialog");
        d.add(com.codename1.ui.layouts.BorderLayout.CENTER,
                new com.codename1.components.SpanLabel("An ad would play here. Install an ad network cn1lib "
                        + "to show real ones."));
        d.setTimeout(1500);
        d.show();
        granted.run();
    }
}

/// The app's push key, from the Push section of the Codename One console.
/// Empty, the app registers for no notifications: everything still works,
/// and a phone in a pocket simply hears nothing until it is opened.
public static final String PUSH_APP_KEY = "";

/// `skirmish.push.provider` is one of:
///
/// - `cloud`: the Codename One push service. It needs `skirmish.push.app`,
///   the app's push id, and `skirmish.push.key`, a server key with the push
///   scope; both are in the Push section of the Codename One console.
/// - `console`: prints each notification, on a development profile only.
/// - `recording`: keeps each notification for the tests to read, on a
///   development profile only.
///
/// Unset, it is `recording` on the `test` profile, `console` on the other
/// development profiles and `cloud` otherwise. A server whose push settings
/// are missing still starts and still serves deliveries: it logs a configuration
/// error at start-up and again for every notification it could not send.
@Bean
public PushSender pushSender(Config config,
        @Value("${skirmish.push.provider:}") String chosen,
        @Value("${skirmish.push.app:}") String app,
        @Value("${skirmish.push.key:}") String key,
        @Value("${skirmish.push.url:}") String url) {
    String kind = chosen.trim().length() > 0 ? chosen.trim()
            : "test".equals(config.getProfile()) ? "recording"
            : config.isDevelopmentProfile() ? "console" : "cloud";
    if ("console".equalsIgnoreCase(kind) || "recording".equalsIgnoreCase(kind)) {
        if (!config.isDevelopmentProfile()) {
            return new MisconfiguredPushSender("skirmish.push.provider=" + kind
                    + " sends nothing and is refused on the '" + config.getProfile()
                    + "' profile; set it to cloud");
        }
        return "console".equalsIgnoreCase(kind) ? new ConsolePushSender()
                : new RecordingPushSender();
    }
    if (!"cloud".equalsIgnoreCase(kind)) {
        return new MisconfiguredPushSender("skirmish.push.provider is '" + kind
                + "', which is none of cloud, console or recording");
    }
    String missing = missing("skirmish.push.", new String[] {"app", app, "key", key});
    if (missing.length() > 0) {
        return new MisconfiguredPushSender(unset("push", "cloud", missing));
    }
    try {
        CloudPush push = new CloudPush(app.trim(), key.trim());
        return new CloudPushSender(url.trim().length() > 0 ? push.withEndpoint(url.trim())
                : push);
    } catch (IllegalArgumentException err) {
        return new MisconfiguredPushSender("push provider 'cloud' is misconfigured: "
                + err.getMessage());
    }
}

@Component
public class Flags {
    public static final String REPORT = "REPORT";
    public static final String AUTO = "AUTO";

    private final FlagRepository flags;
    private final ProfileRepository profiles;
    private final MatchRecordRepository matches;
    private final GamePushes pushes;
    private final AdminChannel channel;
    private final List<String> adminNames;

    public Flags(FlagRepository flags, ProfileRepository profiles, MatchRecordRepository matches,
            GamePushes pushes, AdminChannel channel, @Value("${skirmish.admin.notify:}") String adminNames) {
        this.flags = flags;
        this.profiles = profiles;
        this.matches = matches;
        this.pushes = pushes;
        this.channel = channel;
        this.adminNames = com.codenameone.examples.skirmish.account.Lists.split(adminNames);
    }

    /// A player reporting the opponent of a match they played.
    @Transactional(rollbackFor = IOException.class)
    public FlagDto report(String reporter, String matchId, String reason) throws IOException {
        MatchRecord m = matchId == null ? null : matches.findById(matchId);
        if (m == null || !(reporter.equals(m.getPlayer0()) || reporter.equals(m.getPlayer1()))) {
            throw new ResponseStatusException(404, "No such match");
        }
        String accused = reporter.equals(m.getPlayer0()) ? m.getPlayer1() : m.getPlayer0();
        if (accused.length() == 0) {
            throw new ResponseStatusException(400, "The training bot cannot be reported");
        }
        if (flags.countByReporterAndMatchId(reporter, matchId) > 0) {
            throw new ResponseStatusException(409, "You already reported this match");
        }
        String why = Text.required(reason, 255, "what happened");
        return raise(accused, REPORT, why, matchId, reporter);
    }

    /// Something the server noticed itself. Transactional on its own because
    /// the demo seeding calls it with no transaction open; inside one (a match
    /// being recorded) it joins that one.
    @Transactional(rollbackFor = IOException.class)
    public void auto(String username, String reason, String matchId) {
        try {
            raise(username, AUTO, reason, matchId == null ? "" : matchId, "");
        } catch (IOException | RuntimeException failed) {
            System.err.println("[flags] could not flag " + username + ": " + failed);
        }
    }

    FlagDto raise(String username, String kind, String reason, String matchId, String reporter)
            throws IOException {
        Flag f = store(username, kind, reason, matchId, reporter);
        channel.flagged(username, reason);
        pushes.flagRaised(adminNames, username, reason);
        return toDto(f, profiles.findById(username));
    }

    @Transactional(rollbackFor = IOException.class)
    Flag store(String username, String kind, String reason, String matchId, String reporter)
            throws IOException {
        Flag f = new Flag();
        f.setId(Ids.next());
        f.setUsername(username);
        f.setKind(kind);
        f.setReason(reason);
        f.setMatchId(matchId);
        f.setReporter(reporter);
        f.setCreatedAt(Clock.now());
        f.setPending(true);
        flags.insert(f);
        Profile p = profiles.findById(username);
        if (p != null && !p.isFlagged()) {
            p.setFlagged(true);
            profiles.save(p);
        }
        return f;
    }

    @Transactional(rollbackFor = IOException.class)
    public FlagDto resolve(String admin, String id) {
        Flag f = flags.findById(id);
        if (f == null) {
            throw new ResponseStatusException(404, "No such flag");
        }
        f.setPending(false);
        f.setResolvedBy(admin);
        flags.save(f);
        Profile p = profiles.findById(f.getUsername());
        if (p != null && flags.countByUsernameAndPendingTrue(f.getUsername()) == 0) {
            p.setFlagged(false);
            profiles.save(p);
        }
        return toDto(f, p);
    }

    @Transactional(readOnly = true)
    public List<FlagDto> list(boolean pending) {
        List<FlagDto> out = new ArrayList<FlagDto>();
        for (Flag f : flags.inState(pending, new PageRequest(0, 200))) {
            out.add(toDto(f, profiles.findById(f.getUsername())));
        }
        return out;
    }

    @Transactional(readOnly = true)
    public List<FlagDto> of(String username) {
        List<FlagDto> out = new ArrayList<FlagDto>();
        Profile p = profiles.findById(username);
        for (Flag f : flags.of(username, new PageRequest(0, 50))) {
            out.add(toDto(f, p));
        }
        return out;
    }

    public long pendingCount() {
        return flags.countByPendingTrue();
    }

    static FlagDto toDto(Flag f, Profile p) {
        return new FlagDto(f.getId(), f.getUsername(), p == null ? f.getUsername() : p.getDisplayName(),
                f.getKind(), f.getReason(), f.getMatchId(), f.getReporter(), f.getCreatedAt(), f.isPending());
    }
}

/// Opens the share sheet with the player's invite link.
public static void share(InviteDto mine) {
    Invite invite = Invites.create(InviteRequest.create()
            .campaign(CAMPAIGN)
            .channel("share_sheet")
            .payload(mine.code())
            .title("Join me in Skirmish")
            .description("A real-time card battle. Build a deck and fight me.")
            .build());
    Invites.share(invite, "Battle me in Skirmish! You get " + mine.friendCoins()
            + " coins to start with: " + invite.getUrl());
    Telemetry.inviteSent(CAMPAIGN);
}

/// From the app's start(): pick up an invite this launch carries.
public static void start() {
    Invites.setInviteListener(new InviteListener() {
        @Override
        public void inviteReceived(InviteAttribution a) {
            if (a.getPayload() == null || a.getPayload().length() == 0) {
                // A campaign link from the console: attributed in
                // analytics, nobody to reward.
                return;
            }
            Preferences.set(PENDING + "code", a.getPayload());
            Preferences.set(PENDING + "campaign", a.getCampaign() == null ? "" : a.getCampaign());
            Preferences.set(PENDING + "channel", a.getChannel() == null ? "" : a.getChannel());
            Preferences.set(PENDING + "match", a.getMatchType() == null ? "" : a.getMatchType());
            if (Session.user() != null) {
                Ui.later(Friends::claimPending);
            }
        }

        @Override
        public void attributionUnavailable(String reason) {
            // The ordinary case: most installs were not invited.
        }
    });
    Invites.checkForInvite();
}

/// The friend's side: the app found an invite and the player is signed in.
@Transactional(rollbackFor = IOException.class)
public RewardDto claim(String username, InviteClaimDto claim) throws IOException {
    String code = claim == null || claim.code() == null ? "" : claim.code().trim();
    ReferralCode owner = code.length() == 0 ? null : codes.findById(code);
    if (owner == null) {
        throw new ResponseStatusException(404, "That invite is not known");
    }
    String inviter = owner.getUsername();
    if (inviter.equals(username)) {
        throw new ResponseStatusException(400, "That is your own invite");
    }
    if (referrals.findById(username) != null) {
        throw new ResponseStatusException(409, "An invite was already counted for you");
    }
    Referral back = referrals.findById(inviter);
    if (back != null && back.getInviter().equals(username)) {
        throw new ResponseStatusException(400, "You invited that player");
    }
    Profile p = profiles.findById(username);
    if (p == null || p.getCreatedAt() < Clock.now() - CLAIM_DAYS * Clock.DAY) {
        throw new ResponseStatusException(400, "Invites count for new players only");
    }
    Referral r = new Referral();
    r.setInvitee(username);
    r.setInviter(inviter);
    r.setCode(code);
    r.setCampaign(clip(claim.campaign(), 40));
    r.setChannel(clip(claim.channel(), 40));
    r.setMatchType(clip(claim.match(), 20));
    r.setState(JOINED);
    r.setJoinedAt(Clock.now());
    referrals.insert(r);
    Profile from = profiles.findById(inviter);
    pushes.friendJoined(inviter, p.getDisplayName());
    return progression.missionReward(username,
            "A gift from " + (from == null ? "your friend" : from.getDisplayName()), FRIEND_COINS, 0);
}

@Transactional(rollbackFor = IOException.class)
public BroadcastDto broadcast(String admin, BroadcastDto b) throws IOException {
    check(b, true);
    long now = Clock.now();
    if (broadcasts.countBySentAtGreaterThan(now - Clock.DAY) >= MAX_BROADCASTS_PER_DAY) {
        throw new ResponseStatusException(429, "At most " + MAX_BROADCASTS_PER_DAY
                + " broadcasts a day: players who are pushed too often switch notifications off");
    }
    String id = Ids.next();
    String campaign = b.campaign() == null || b.campaign().trim().length() == 0
            ? "broadcast-" + id.substring(0, 8) : b.campaign().trim();
    int reached = pushes.broadcast(audienceOf(b), id, b.title().trim(), b.body().trim(), screen(b.screen()),
            campaign);
    Broadcast row = new Broadcast();
    row.setId(id);
    row.setSegment(b.segment());
    row.setDays(b.days());
    row.setTitle(b.title().trim());
    row.setBody(b.body().trim());
    row.setScreen(screen(b.screen()));
    row.setCampaign(campaign.length() > 40 ? campaign.substring(0, 40) : campaign);
    row.setTargets(reached);
    row.setSentBy(admin);
    row.setSentAt(now);
    broadcasts.insert(row);
    record(admin, "BROADCAST", b.segment() + ": " + b.title().trim());
    return dto(row);
}

// The store's own rating prompt, asked only of a player who has come
// back: five launches over three days, and never twice in a month.
// ResultForm asks after a win, the moment a player is happiest.
AppReview.getInstance().setMinimumLaunches(5).setMinimumDaysInstalled(3)
        .setDaysBetweenPrompts(30).registerSession();

// On a desktop or a tablet the console is a side bar and a page, the
// way an operator's tools usually are; on a phone, tabs along the top.
if (wide()) {
    tabs.setTabPlacement(Component.LEFT);
    tabs.setTabTextPosition(Component.RIGHT);
} else {
    // Nine tabs do not fit across a phone: they scroll sideways.
    tabs.getTabsContainer().setScrollableX(true);
    tabs.setTabTextPosition(Component.BOTTOM);
}

/// A label and its field on one line, the label in a column of its own,
/// right aligned, so every field of a form starts at the same place.
static Container field(String label, Component input) {
    Label l = new Label(label, "DeskLabel");
    l.setPreferredW(CN.convertToPixels(AdminConsole.wide() ? WIDE_LABEL_MM : LABEL_MM));
    Container c = new Container(new BorderLayout());
    c.setUIID("DeskFieldRow");
    c.add(BorderLayout.WEST, l).add(BorderLayout.CENTER, input);
    return c;
}

/// Every enabled pipeline, once an hour, on one server at a time.
/// Transactional itself: a call to [#run] from here is a call on `this`,
/// which does not go through the transaction wrapper.
@Scheduled(fixedDelay = EVERY, initialDelay = 5L * 60 * 1000, lock = "skirmish-pipelines")
@Transactional(rollbackFor = IOException.class)
public void runAll() throws IOException {
    for (Pipeline p : pipelines.byName()) {
        if (p.isEnabled()) {
            run(p.getId());
        }
    }
}

public static final int MAX_CARDS = 40;
public static final int MAX_ARENAS = 10;
public static final int MAX_MISSIONS = 60;
public static final int MAX_CAMPAIGNS = 10;
public static final int MAX_CAMPAIGN_MISSIONS = 30;
public static final int MAX_ASSETS = 40;
public static final int MAX_DIALOG = 60;
public static final int MAX_TEXT = 280;
public static final int MAX_LONG_TEXT = 1200;
/// A model travels base64 encoded in one request, under the server's 8 MB body limit.
public static final int MAX_MODEL_BYTES = 5 * 1024 * 1024;
public static final int MAX_IMAGE_BYTES = 1024 * 1024;
/// What any one mission may pay, on top of the server's caps for packs that
/// are not official.
public static final int MAX_REWARD_COINS = 500;
public static final int MAX_REWARD_XP = 200;

Match played;
try {
    played = MissionRun.verify(pack, ref.mission, replay);
} catch (IllegalArgumentException e) {
    throw new ResponseStatusException(400, e.getMessage());
}
int won = mission.stars(played);

String key = Ids.sha256(username + "|" + p.getId() + "|" + ref.mission);
MissionStars row = stars.findById(key);
if (row == null) {
    row = new MissionStars();
    row.setId(key);
    row.setUsername(username);
    row.setPackId(p.getId());
    row.setMissionId(ref.mission);
    stars.insert(row);
}
row.setPlays(row.getPlays() + 1);
row.setStars(Math.max(row.getStars(), won));
int newStars = Math.max(0, won - row.getPaidStars());
row.setPaidStars(row.getPaidStars() + newStars);
row.setUpdatedAt(Clock.now());
stars.save(row);
p.setPlays(p.getPlays() + 1);
packs.save(p);

int coins = mission.rewardCoins * newStars / 3;
int xp = mission.rewardXp * newStars / 3;
if (username.equals(p.getOwner())) {
    // Testing your own mission is free, and pays nothing.
    coins = 0;
    xp = 0;
} else if (!p.isOfficial()) {
    coins = Math.min(coins, COMMUNITY_MISSION_COINS * newStars / 3);
    xp = Math.min(xp, COMMUNITY_MISSION_XP * newStars / 3);
    coins = spendDailyAllowance(username, coins);
}

public final class MissionPlay {
    private MissionPlay() {
    }

    public static void start(final ContentPack pack, final String missionId, final boolean test,
            final Runnable back) {
        List<String> files = new ArrayList<String>();
        for (CardDef c : pack.cards) {
            if (c.model() != null && c.model().startsWith("asset:")) {
                files.add(c.model().substring(6));
            }
        }
        ForgeFiles.fetch(files, () -> Ui.later(() -> battle(pack, missionId, test, back)), Ui::failed);
    }

    private static void battle(final ContentPack pack, String missionId, final boolean test, final Runnable back) {
        MissionDef m = pack.mission(missionId);
        CardSet cards = pack.cardSet();
        CardArt.use(cards);
        MissionDriver driver = new MissionDriver(pack, missionId, System.currentTimeMillis(),
                m.playerDeck == null ? ownDeck(cards) : null);
        BattleForm.mission(driver, new BattleForm.MissionEnd() {
            @Override
            public void finished(MissionDriver d) {
                CardArt.use(null);
                int stars = d.run().stars();
                if (test) {
                    Dialog.show(stars > 0 ? "Won" : "Lost", stars > 0 ? PackScreen.starText(stars)
                            + "  -- a test battle counts for nothing." : "The enemy won this one.", "OK", null);
                    back.run();
                    return;
                }
                Api.forge().result(new MissionResultDto(d.run().replay().encode()), Net.to(
                        outcome -> Ui.later(() -> Rewards.show(outcome.reward(), back)), (status, message) -> {
                            Ui.failed(status, message);
                            back.run();
                        }));
            }

            @Override
            public void left(MissionDriver d) {
                CardArt.use(null);
                back.run();
            }
        });
    }

    /// The player's saved deck when the pack's cards allow it, else the
    /// starter deck: a mission that leaves the deck to the player may still
    /// run on a pack that changed which cards there are.
    private static String[] ownDeck(CardSet cards) {
        if (Session.user() != null && Session.user().deck() != null) {
            List<String> d = Session.user().deck();
            String[] deck = d.toArray(new String[d.size()]);
            if (cards.isValidDeck(deck)) {
                return deck;
            }
        }
        return Deck.starter();
    }
}