Skip to content

N
Neos
Commit 2d1ca98c authored by biluo.shen's avatar biluo.shen
Browse files
Options

Add AI predict

parent d27fb2f1
Pipeline #28077 failed with stages
            in 32 seconds
            Show whitespace changes
            Inline Side-by-side
            Showing with 964 additions and 315 deletions
            src/api/ygoAgent/predict.ts
            View file @ 2d1ca98c
            ......@@ -5,7 +5,7 @@ import { Input, MsgResponse } from "./schema";
            import { agentHeader } from "./util";
            const { agentServer } = useConfig();
            const apiPath = (duelId: string) => `${agentServer}/v0/duels/${duelId}/predict`;
            const apiPath = (duelId: string) => `v0/duels/${duelId}/predict`;
            export interface PredictReq {
            /**
            ......@@ -13,6 +13,7 @@ export interface PredictReq {
            */
            index: number;
            input: Input;
            prev_action_idx: number;
            }
            interface PredictResp {
            ......@@ -27,7 +28,10 @@ export async function predictDuel(
            duelId: string,
            req: PredictReq,
            ): Promise<PredictResp | undefined> {
            const headers = agentHeader();
            const headers = {
            ...agentHeader(),
            'Content-Type': 'application/json',
            };
            const resp = await fetch(`${agentServer}/${apiPath(duelId)}`, {
            method: "POST",
            ......
            src/api/ygoAgent/schema.ts
            View file @ 2d1ca98c
            /* Generated from https://1ewzpubatn.apifox.cn/api-178477939 */
            export interface Input {
            action_msg: ActionMsg;
            cards: Card[];
            global: Global;
            }
            import { ygopro } from "@/api";
            import { CardType } from "@/stores/cardStore";
            import { extraCardTypes } from "@/common";
            export interface ActionMsg {
            data: Data;
            name: Name;
            }
            import GM = ygopro.StocGameMessage;
            /**
            * MsgSelectCard
            *
            * MsgSelectTribute
            *
            * MsgSelectSum
            *
            * MsgSelectIdleCmd
            *
            * MsgSelectChain
            *
            * MsgSelectPosition
            *
            * MsgSelectEffectYn
            *
            * MsgSelectYesNo
            *
            * MsgSelectBattleCmd
            *
            * MsgSelectUnselectCard
            *
            * MsgSelectOption
            *
            * MsgSelectPlace
            *
            * MsgSelectDisfield
            *
            * MsgAnnounceAttrib
            *
            * MsgAnnounceNumber
            */
            export interface Data {
            /**
            * ignored
            */
            cancelable?: boolean;
            cards?: CardElement[];
            max?: number;
            min?: number;
            /**
            * the indices of the selected `cards`
            */
            selected?: number[];
            level_sum?: number;
            /**
            * size > 2 not supported
            */
            must_cards?: MustCard[];
            /**
            * true not supported
            */
            overflow?: boolean;
            idle_cmds?: IdleCmd[];
            chains?: Chain[];
            forced?: boolean;
            code?: number;
            positions?: PositionElement[];
            effect_description?: number;
            location?: LocationObject;
            battle_cmds?: BattleCmd[];
            finishable?: boolean;
            selectable_cards?: LocationObject[];
            /**
            * ignored
            */
            selected_cards?: LocationObject[];
            /**
            * ignored
            */
            options?: Option[];
            /**
            * > 1 not supported; 0 is considered as 1.
            *
            * != 1 not supported
            * none for N/A or unknown or token.
            */
            count?: number;
            places?: Place[];
            attributes?: AttributeElement[];
            numbers?: number[];
            [property: string]: any;
            }
            export enum AttributeElement {
            Dark = "dark",
            Divine = "divine",
            enum Attribute {
            None = "none",
            Earth = "earth",
            Fire = "fire",
            Light = "light",
            Water = "water",
            Fire = "fire",
            Wind = "wind",
            Light = "light",
            Dark = "dark",
            Divine = "divine",
            }
            export interface BattleCmd {
            cmd_type: BattleCmdCmdType;
            data?: null | PurpleData;
            }
            export enum BattleCmdCmdType {
            Activate = "activate",
            Attack = "attack",
            ToEp = "to_ep",
            ToM2 = "to_m2",
            }
            export interface PurpleData {
            card_info: CardInfo;
            direct_attackable: boolean;
            effect_description: number;
            }
            /**
            * CardInfo
            */
            export interface CardInfo {
            code: number;
            controller: Controller;
            location: LocationEnum;
            /**
            * Start from 0
            */
            sequence: number;
            // from common.ts ATTRIBUTE_*
            // TODO (ygo-agent): replace literal numbers with constants
            function numberToAttribute(attributeNumber: number): Attribute {
            switch (attributeNumber) {
            case 0x00:
            return Attribute.None;
            case 0x01:
            return Attribute.Earth;
            case 0x02:
            return Attribute.Water;
            case 0x04:
            return Attribute.Fire;
            case 0x08:
            return Attribute.Wind;
            case 0x10:
            return Attribute.Light;
            case 0x20:
            return Attribute.Dark;
            case 0x40:
            return Attribute.Divine;
            default:
            throw new Error(`Unknown attribute number: ${attributeNumber}`);
            }
            }
            export enum Controller {
            enum Controller {
            Me = "me",
            Opponent = "opponent",
            }
            export enum LocationEnum {
            //
            enum Location {
            Deck = "deck",
            Extra = "extra",
            Grave = "grave",
            Hand = "hand",
            Mzone = "mzone",
            MZone = "mzone",
            Removed = "removed",
            Szone = "szone",
            SZone = "szone",
            }
            /**
            * CardLocation
            */
            export interface CardElement {
            controller?: Controller;
            location: LocationEnum | LocationObject;
            /**
            * if is overlay, this is the overlay index, starting from 0, else -1.
            */
            overlay_sequence?: number;
            /**
            * Start from 0
            */
            sequence?: number;
            level?: number;
            level1?: number;
            /**
            * ignored
            */
            level2?: number;
            function cardZoneToLocation(zone: ygopro.CardZone): Location {
            switch (zone) {
            case ygopro.CardZone.DECK:
            return Location.Deck;
            case ygopro.CardZone.HAND:
            return Location.Hand;
            case ygopro.CardZone.MZONE:
            return Location.MZone;
            case ygopro.CardZone.SZONE:
            return Location.SZone;
            case ygopro.CardZone.GRAVE:
            return Location.Grave;
            case ygopro.CardZone.REMOVED:
            return Location.Removed;
            case ygopro.CardZone.EXTRA:
            return Location.Extra;
            default:
            throw new Error(`Unknown card zone: ${zone}`);
            }
            }
            /**
            * CardLocation
            */
            export interface LocationObject {
            interface Place {
            controller: Controller;
            location: LocationEnum;
            /**
            * if is overlay, this is the overlay index, starting from 0, else -1.
            */
            overlay_sequence: number;
            location: Location;
            /**
            * Start from 0
            */
            sequence: number;
            }
            export interface Chain {
            interface Option {
            code: number;
            effect_description: number;
            location: LocationObject;
            }
            export interface IdleCmd {
            cmd_type: IdleCmdCmdType;
            data?: null | FluffyData;
            }
            export enum IdleCmdCmdType {
            Activate = "activate",
            Mset = "mset",
            Reposition = "reposition",
            Set = "set",
            SpSummon = "sp_summon",
            Summon = "summon",
            ToBp = "to_bp",
            ToEp = "to_ep",
            }
            export interface FluffyData {
            card_info: CardInfo;
            effect_description: number;
            }
            export interface MustCard {
            level1: number;
            interface CardLocation {
            controller: Controller;
            location: Location;
            /**
            * ignored
            * if is overlay, this is the overlay index, starting from 0, else -1.
            */
            level2: number;
            location: LocationObject;
            }
            export interface Option {
            code: number;
            }
            export interface Place {
            controller: Controller;
            location: LocationEnum;
            overlay_sequence: number;
            /**
            * Start from 0
            */
            sequence: number;
            }
            export enum PositionElement {
            Attack = "attack",
            Defense = "defense",
            Facedown = "facedown",
            FacedownAttack = "facedown_attack",
            FacedownDefense = "facedown_defense",
            Faceup = "faceup",
            FaceupAttack = "faceup_attack",
            FaceupDefense = "faceup_defense",
            function convertController(controller: number, player: number): Controller {
            return controller === player ? Controller.Me : Controller.Opponent;
            }
            export enum Name {
            AnnounceAttrib = "announce_attrib",
            AnnounceNumber = "announce_number",
            SelectBattlecmd = "select_battlecmd",
            SelectCard = "select_card",
            SelectChain = "select_chain",
            SelectDisfield = "select_disfield",
            SelectEffectyn = "select_effectyn",
            SelectIdlecmd = "select_idlecmd",
            SelectOption = "select_option",
            SelectPlace = "select_place",
            SelectPosition = "select_position",
            SelectSum = "select_sum",
            SelectTribute = "select_tribute",
            SelectUnselectCard = "select_unselect_card",
            SelectYesno = "select_yesno",
            }
            /**
            * Card
            */
            export interface Card {
            attack: number;
            /**
            * none for N/A or unknown or token.
            */
            attribute: CardAttribute;
            /**
            * Card code from cards.cdb
            */
            code: number;
            controller: Controller;
            /**
            * Number of counters. If there are 2 types of counters or more, we consider only the first
            * type of counter.
            */
            counter: number;
            defense: number;
            /**
            * Rank and link are also considered as level. 0 is N/A or unknown.
            */
            level: number;
            location: LocationEnum;
            /**
            * Whether the card effect is disabled or forbidden
            */
            negated: boolean;
            /**
            * if is overlay, this is the overlay index, starting from 0, else -1.
            */
            overlay_sequence: number;
            /**
            * If the monster is xyz material (overlay_sequence != -1), the position is faceup.
            */
            position: CardPosition;
            /**
            * none for N/A or unknown or token.
            */
            race: Race;
            /**
            * Sequence in ocgcore, 0 is N/A or unknown, if not, shoud start from 1. Only non-zero for
            * cards in mzone, szone and grave.
            */
            sequence: number;
            types: Type[];
            function convertOverlaySequence(cl: ygopro.CardLocation): number {
            return cl.is_overlay ? cl.overlay_sequence : -1;
            }
            /**
            * none for N/A or unknown or token.
            */
            export enum CardAttribute {
            Dark = "dark",
            Divine = "divine",
            Earth = "earth",
            Fire = "fire",
            Light = "light",
            None = "none",
            Water = "water",
            Wind = "wind",
            function convertCardLocation(cl: ygopro.CardLocation, player: number): CardLocation {
            return {
            controller: convertController(cl.controller, player),
            location: cardZoneToLocation(cl.zone),
            overlay_sequence: convertOverlaySequence(cl),
            sequence: cl.sequence,
            };
            }
            /**
            * If the monster is xyz material (overlay_sequence != -1), the position is faceup.
            */
            export enum CardPosition {
            Attack = "attack",
            Defense = "defense",
            Facedown = "facedown",
            FacedownAttack = "facedown_attack",
            FacedownDefense = "facedown_defense",
            Faceup = "faceup",
            enum Position {
            None = "none",
            FaceupAttack = "faceup_attack",
            FacedownAttack = "facedown_attack",
            Attack = "attack",
            FaceupDefense = "faceup_defense",
            None = "none",
            Faceup = "faceup",
            FacedownDefense = "facedown_defense",
            Facedown = "facedown",
            Defense = "defense",
            }
            function convertPosition(position: ygopro.CardPosition): Position {
            switch (position) {
            case ygopro.CardPosition.FACEUP_ATTACK:
            return Position.FaceupAttack;
            case ygopro.CardPosition.FACEDOWN_ATTACK:
            return Position.FacedownAttack;
            case ygopro.CardPosition.FACEUP_DEFENSE:
            return Position.FaceupDefense;
            case ygopro.CardPosition.FACEDOWN_DEFENSE:
            return Position.FacedownDefense;
            case ygopro.CardPosition.FACEUP:
            return Position.Faceup;
            case ygopro.CardPosition.FACEDOWN:
            return Position.Facedown;
            case ygopro.CardPosition.ATTACK:
            return Position.Attack;
            case ygopro.CardPosition.DEFENSE:
            return Position.Defense;
            default:
            throw new Error(`Unknown card position: ${position}`);
            }
            }
            /**
            * none for N/A or unknown or token.
            */
            export enum Race {
            enum Race {
            Aqua = "aqua",
            Beast = "beast",
            BeastWarrior = "beast_warrior",
            ......@@ -375,7 +196,42 @@ export enum Race {
            Zombie = "zombie",
            }
            export enum Type {
            // from common.ts RACE_*
            // TODO (ygo-agent): replace literal numbers with constants
            function numberToRace(raceNumber: number): Race {
            switch (raceNumber) {
            case 0x0: return Race.None;
            case 0x1: return Race.Warrior;
            case 0x2: return Race.Spellcaster;
            case 0x4: return Race.Fairy;
            case 0x8: return Race.Fiend;
            case 0x10: return Race.Zombie;
            case 0x20: return Race.Machine;
            case 0x40: return Race.Aqua;
            case 0x80: return Race.Pyro;
            case 0x100: return Race.Rock;
            case 0x200: return Race.Windbeast;
            case 0x400: return Race.Plant;
            case 0x800: return Race.Insect;
            case 0x1000: return Race.Thunder;
            case 0x2000: return Race.Dragon;
            case 0x4000: return Race.Beast;
            case 0x8000: return Race.BeastWarrior;
            case 0x10000: return Race.Dinosaur;
            case 0x20000: return Race.Fish;
            case 0x40000: return Race.SeaSerpent;
            case 0x80000: return Race.Reptile;
            case 0x100000: return Race.Psycho;
            case 0x200000: return Race.Devine;
            case 0x400000: return Race.CreatorGod;
            case 0x800000: return Race.Wyrm;
            case 0x1000000: return Race.Cyberse;
            default:
            throw new Error(`Unknown race number: ${raceNumber}`);
            }
            }
            enum Type {
            Continuous = "continuous",
            Counter = "counter",
            Dual = "dual",
            ......@@ -403,22 +259,119 @@ export enum Type {
            Xyz = "xyz",
            }
            /**
            * Global
            // from common.ts TYPE_*
            // TODO (ygo-agent): replace literal numbers with constants
            function numberToType(typeNumber: number): Type {
            switch (typeNumber) {
            case 0x1: return Type.Monster;
            case 0x2: return Type.Spell;
            case 0x4: return Type.Trap;
            case 0x10: return Type.Normal;
            case 0x20: return Type.Effect;
            case 0x40: return Type.Fusion;
            case 0x80: return Type.Ritual;
            case 0x100: return Type.TrapMonster;
            case 0x200: return Type.Spirit;
            case 0x400: return Type.Union;
            case 0x800: return Type.Dual;
            case 0x1000: return Type.Tuner;
            case 0x2000: return Type.Synchro;
            case 0x4000: return Type.Token;
            case 0x10000: return Type.QuickPlay;
            case 0x20000: return Type.Continuous;
            case 0x40000: return Type.Equip;
            case 0x80000: return Type.Field;
            case 0x100000: return Type.Counter;
            case 0x200000: return Type.Flip;
            case 0x400000: return Type.Toon;
            case 0x800000: return Type.Xyz;
            case 0x1000000: return Type.Pendulum;
            case 0x2000000: return Type.Special;
            case 0x4000000: return Type.Link;
            default: throw new Error(`Unknown type number: ${typeNumber}`);
            }
            }
            interface Card {
            /**
            * Card code from cards.cdb
            */
            export interface Global {
            code: number;
            location: Location;
            /**
            * Whether me is the first player
            * Sequence in ocgcore, 0 is N/A or unknown, if not, shoud start from 1. Only non-zero for
            * cards in mzone, szone and grave.
            */
            is_first: boolean;
            is_my_turn: boolean;
            my_lp: number;
            op_lp: number;
            phase: Phase;
            turn: number;
            sequence: number;
            controller: Controller;
            /**
            * If the monster is xyz material (overlay_sequence != -1), the position is faceup.
            */
            position: Position;
            /**
            * if is overlay, this is the overlay index, starting from 0, else -1.
            */
            overlay_sequence: number;
            /**
            * none for N/A or unknown or token.
            */
            attribute: Attribute;
            /**
            * none for N/A or unknown or token.
            */
            race: Race;
            /**
            * Rank and link are also considered as level. 0 is N/A or unknown.
            */
            level: number;
            /**
            * Number of counters. If there are 2 types of counters or more, we consider only the first
            * type of counter.
            */
            counter: number;
            /**
            * Whether the card effect is disabled or forbidden
            */
            negated: boolean;
            attack: number;
            defense: number;
            types: Type[];
            }
            function getCounter(counters: { [type: number]: number }) {
            if (counters) {
            for (const type in counters) {
            return counters[type];
            }
            }
            return 0;
            }
            export function convertCard(card: CardType, player: number): Card {
            // TODO (ygo-agent): unseen cards
            return {
            code: card.code,
            location: cardZoneToLocation(card.location.zone),
            sequence: card.location.sequence + 1,
            controller: convertController(card.location.controller, player),
            position: convertPosition(card.location.position),
            overlay_sequence: convertOverlaySequence(card.location),
            attribute: numberToAttribute(card.meta.data.attribute ?? 0),
            race: numberToRace(card.meta.data.race ?? 0),
            level: card.meta.data.level ?? 0,
            counter: getCounter(card.counters),
            // TODO (ygo-agent): add negated
            negated: false,
            attack: card.meta.data.atk ?? 0,
            defense: card.meta.data.def ?? 0,
            types: extraCardTypes(card.meta.data.type ?? 0).map(numberToType),
            }
            }
            export enum Phase {
            enum Phase {
            Battle = "battle",
            BattleStart = "battle_start",
            BattleStep = "battle_step",
            ......@@ -431,6 +384,578 @@ export enum Phase {
            Standby = "standby",
            }
            import _Phase = GM.MsgNewPhase.PhaseType;
            export function convertPhase(phase: _Phase): Phase {
            switch (phase) {
            case _Phase.DRAW:
            return Phase.Draw;
            case _Phase.STANDBY:
            return Phase.Standby;
            case _Phase.MAIN1:
            return Phase.Main1;
            case _Phase.BATTLE_START:
            return Phase.BattleStart;
            case _Phase.BATTLE_STEP:
            return Phase.BattleStep;
            case _Phase.DAMAGE_GAL:
            return Phase.DamageCalculation;
            case _Phase.DAMAGE:
            return Phase.Damage;
            case _Phase.BATTLE:
            return Phase.Battle;
            case _Phase.MAIN2:
            return Phase.Main2;
            case _Phase.END:
            return Phase.End;
            default:
            throw new Error(`Unknown phase: ${phase}`);
            }
            }
            export interface Global {
            /**
            * Whether me is the first player
            */
            is_first: boolean;
            is_my_turn: boolean;
            my_lp: number;
            op_lp: number;
            phase: Phase;
            turn: number;
            }
            export function parsePlayerFromMsg(msg: GM): number {
            if (
            msg instanceof GM.MsgSelectCard ||
            msg instanceof GM.MsgSelectTribute ||
            msg instanceof GM.MsgSelectSum ||
            msg instanceof GM.MsgSelectIdleCmd ||
            msg instanceof GM.MsgSelectChain ||
            msg instanceof GM.MsgSelectPosition ||
            msg instanceof GM.MsgSelectEffectYn ||
            msg instanceof GM.MsgSelectYesNo ||
            msg instanceof GM.MsgSelectBattleCmd ||
            msg instanceof GM.MsgSelectUnselectCard ||
            msg instanceof GM.MsgSelectOption ||
            msg instanceof GM.MsgSelectPlace ||
            msg instanceof GM.MsgAnnounce
            ) {
            return msg.player;
            }
            throw new Error(`Unsupported message type: ${msg}`);
            }
            interface MsgSelectCard {
            cancelable: boolean;
            min: number;
            max: number;
            cards: CardLocation[];
            selected: number[];
            }
            function convertMsgSelectCard(msg: GM.MsgSelectCard): MsgSelectCard {
            return {
            cancelable: msg.cancelable,
            min: msg.min,
            max: msg.max,
            cards: msg.cards.map(c => convertCardLocation(c.location, msg.player)),
            // TODO (ygo-agent): the indices of the selected `cards`
            selected: [],
            };
            }
            interface SelectTributeCard {
            location: CardLocation;
            level: number;
            }
            interface MsgSelectTribute {
            cancelable: boolean;
            min: number;
            max: number;
            cards: SelectTributeCard[];
            selected: number[];
            }
            function convertMsgSelectTribute(msg: GM.MsgSelectTribute): MsgSelectTribute {
            return {
            cancelable: msg.cancelable,
            min: msg.min,
            max: msg.max,
            cards: msg.selectable_cards.map(c => ({
            location: convertCardLocation(c.location, msg.player),
            level: c.level,
            })),
            // TODO (ygo-agent): the indices of the selected `cards`
            selected: [],
            };
            }
            interface SelectSumCard {
            location: CardLocation;
            level1: number;
            level2: number;
            }
            interface MsgSelectSum {
            overflow: boolean;
            level_sum: number;
            min: number;
            max: number;
            cards: SelectSumCard[];
            must_cards: SelectSumCard[];
            selected: number[];
            }
            function convertMsgSelectSum(msg: GM.MsgSelectSum): MsgSelectSum {
            return {
            overflow: msg.overflow != 0,
            level_sum: msg.level_sum,
            min: msg.min,
            max: msg.max,
            cards: msg.selectable_cards.map(c => ({
            location: convertCardLocation(c.location, msg.player),
            level1: c.level1,
            level2: c.level2,
            })),
            must_cards: msg.must_select_cards.map(c => ({
            location: convertCardLocation(c.location, msg.player),
            level1: c.level1,
            level2: c.level2,
            })),
            // TODO (ygo-agent): the indices of the selected `cards`
            selected: [],
            }
            }
            interface CardInfo {
            code: number;
            controller: Controller;
            location: Location;
            sequence: number;
            }
            function convertCardInfo(cardInfo: ygopro.CardInfo, player: number): CardInfo {
            return {
            code: cardInfo.code,
            controller: convertController(cardInfo.controller, player),
            location: cardZoneToLocation(cardInfo.location),
            sequence: cardInfo.sequence,
            };
            }
            enum IdleCmdType {
            Summon = "summon",
            SpSummon = "sp_summon",
            Reposition = "reposition",
            Mset = "mset",
            Set = "set",
            Activate = "activate",
            ToBp = "to_bp",
            ToEp = "to_ep",
            }
            import _IdleType = GM.MsgSelectIdleCmd.IdleCmd.IdleType;
            function convertIdleCmdType(cmdType: _IdleType): IdleCmdType {
            switch (cmdType) {
            case _IdleType.ACTIVATE:
            return IdleCmdType.Activate;
            case _IdleType.MSET:
            return IdleCmdType.Mset;
            case _IdleType.POS_CHANGE:
            return IdleCmdType.Reposition;
            case _IdleType.SSET:
            return IdleCmdType.Set;
            case _IdleType.SPSUMMON:
            return IdleCmdType.SpSummon;
            case _IdleType.SUMMON:
            return IdleCmdType.Summon;
            case _IdleType.TO_BP:
            return IdleCmdType.ToBp;
            case _IdleType.TO_EP:
            return IdleCmdType.ToEp;
            default:
            throw new Error(`Unknown idle command type: ${cmdType}`);
            }
            }
            interface IdleCmdData {
            card_info: CardInfo;
            effect_description: number;
            }
            interface IdleCmd {
            cmd_type: IdleCmdType;
            data?: IdleCmdData;
            }
            interface MsgSelectIdleCmd {
            idle_cmds: IdleCmd[];
            }
            function convertMsgSelectIdleCmd(msg: GM.MsgSelectIdleCmd): MsgSelectIdleCmd {
            const idle_cmds: IdleCmd[] = [];
            for (const cmd of msg.idle_cmds) {
            for (const data of cmd.idle_datas) {
            const cmd_type = convertIdleCmdType(cmd.idle_type);
            if (
            cmd_type == IdleCmdType.Summon ||
            cmd_type == IdleCmdType.SpSummon ||
            cmd_type == IdleCmdType.Reposition ||
            cmd_type == IdleCmdType.Mset ||
            cmd_type == IdleCmdType.Set ||
            cmd_type == IdleCmdType.Activate
            ) {
            idle_cmds.push({
            cmd_type,
            data: {
            card_info: convertCardInfo(data.card_info, msg.player),
            effect_description: cmd_type == IdleCmdType.Activate ? data.effect_description : 0,
            },
            });
            } else {
            throw new Error(`Unsupported idle command type: ${cmd_type}`);
            }
            }
            }
            if (msg.enable_bp) {
            idle_cmds.push({ cmd_type: IdleCmdType.ToBp });
            }
            if (msg.enable_ep) {
            idle_cmds.push({ cmd_type: IdleCmdType.ToEp });
            }
            return { idle_cmds };
            }
            interface Chain {
            code: number;
            location: CardLocation;
            effect_description: number;
            }
            interface MsgSelectChain {
            forced: boolean;
            chains: Chain[];
            }
            function convertChain(chain: GM.MsgSelectChain.Chain, player: number): Chain {
            return {
            code: chain.code,
            location: convertCardLocation(chain.location, player),
            effect_description: chain.effect_description,
            };
            }
            function convertMsgSelectChain(msg: GM.MsgSelectChain): MsgSelectChain {
            return {
            forced: msg.forced,
            chains: msg.chains.map(c => convertChain(c, msg.player)),
            };
            }
            interface MsgSelectPosition {
            code: number;
            positions: Position[];
            }
            function convertMsgSelectPosition(msg: GM.MsgSelectPosition): MsgSelectPosition {
            return {
            code: msg.code,
            positions: msg.positions.map(p => convertPosition(p.position)),
            };
            }
            interface MsgSelectYesNo {
            effect_description: number;
            }
            function convertMsgSelectYesNo(msg: GM.MsgSelectYesNo): MsgSelectYesNo {
            return {
            effect_description: msg.effect_description,
            };
            }
            interface MsgSelectEffectYn {
            code: number;
            location: CardLocation;
            effect_description: number;
            }
            function convertMsgSelectEffectYn(msg: GM.MsgSelectEffectYn): MsgSelectEffectYn {
            return {
            code: msg.code,
            location: convertCardLocation(msg.location, msg.player),
            effect_description: msg.effect_description,
            };
            }
            enum BattleCmdType {
            Attack = "attack",
            Activate = "activate",
            ToM2 = "to_m2",
            ToEp = "to_ep",
            }
            import _BattleCmdType = GM.MsgSelectBattleCmd.BattleCmd.BattleType;
            function convertBattleCmdType(cmdType: _BattleCmdType): BattleCmdType {
            switch (cmdType) {
            case _BattleCmdType.ATTACK:
            return BattleCmdType.Attack;
            case _BattleCmdType.ACTIVATE:
            return BattleCmdType.Activate;
            default:
            throw new Error(`Unknown battle command type: ${cmdType}`);
            }
            }
            interface BattleCmdData {
            card_info: CardInfo;
            effect_description: number;
            direct_attackable: boolean;
            }
            interface BattleCmd {
            cmd_type: BattleCmdType;
            data?: BattleCmdData;
            }
            interface MsgSelectBattleCmd {
            battle_cmds: BattleCmd[];
            }
            function convertMsgSelectBattleCmd(msg: GM.MsgSelectBattleCmd): MsgSelectBattleCmd {
            const battle_cmds: BattleCmd[] = [];
            for (const cmd of msg.battle_cmds) {
            const cmd_type = convertBattleCmdType(cmd.battle_type);
            for (const data of cmd.battle_datas) {
            const battle_data: BattleCmdData = {
            card_info: convertCardInfo(data.card_info, msg.player),
            effect_description: data.effect_description,
            direct_attackable: data.direct_attackable,
            };
            battle_cmds.push({ cmd_type, data: battle_data });
            }
            }
            if (msg.enable_m2) {
            battle_cmds.push({ cmd_type: BattleCmdType.ToM2 });
            }
            if (msg.enable_ep) {
            battle_cmds.push({ cmd_type: BattleCmdType.ToEp });
            }
            return { battle_cmds };
            }
            interface MsgSelectUnselectCard {
            finishable: boolean;
            cancelable: boolean;
            min: number;
            max: number;
            selected_cards: CardLocation[];
            selectable_cards: CardLocation[];
            }
            function convertMsgSelectUnselectCard(msg: GM.MsgSelectUnselectCard): MsgSelectUnselectCard {
            return {
            finishable: msg.finishable,
            cancelable: msg.cancelable,
            min: msg.min,
            max: msg.max,
            selected_cards: msg.selected_cards.map(c => convertCardLocation(c.location, msg.player)),
            selectable_cards: msg.selectable_cards.map(c => convertCardLocation(c.location, msg.player)),
            };
            }
            interface Option {
            code: number;
            }
            interface MsgSelectOption {
            options: Option[];
            }
            function convertMsgSelectOption(msg: GM.MsgSelectOption): MsgSelectOption {
            return {
            options: msg.options.map(o => ({ code: o.code })),
            };
            }
            interface Place {
            controller: Controller;
            location: Location;
            sequence: number;
            }
            interface MsgSelectPlace {
            count: number;
            places: Place[];
            }
            function convertMsgSelectPlace(msg: GM.MsgSelectPlace): MsgSelectPlace {
            return {
            count: msg.count,
            places: msg.places.map(p => ({
            controller: convertController(p.controller, msg.player),
            location: cardZoneToLocation(p.zone),
            sequence: p.sequence,
            })),
            };
            }
            // TODO (ygo-agent): MsgSelectDisfield
            interface MsgAnnounceAttrib {
            count: number;
            attributes: Attribute[];
            }
            function convertMsgAnnounceAttrib(msg: GM.MsgAnnounce): MsgAnnounceAttrib {
            return {
            count: msg.min,
            // from api/ocgcore/ocgAdapter/stoc/stocGameMsg/announceAttrib.ts
            attributes: msg.options.map(a => numberToAttribute(1 << a.code)),
            };
            }
            interface MsgAnnounceNumber {
            count: number;
            numbers: number[];
            }
            function convertMsgAnnounceNumber(msg: GM.MsgAnnounce): MsgAnnounceNumber {
            return {
            count: msg.min,
            numbers: msg.options.map(o => o.code),
            };
            }
            type ActionMsgData =
            MsgSelectCard |
            MsgSelectTribute |
            MsgSelectSum |
            MsgSelectIdleCmd |
            MsgSelectChain |
            MsgSelectPosition |
            MsgSelectYesNo |
            MsgSelectEffectYn |
            MsgSelectBattleCmd |
            MsgSelectUnselectCard |
            MsgSelectOption |
            MsgSelectPlace |
            MsgAnnounceAttrib |
            MsgAnnounceNumber;
            enum ActionMsgName {
            AnnounceAttrib = "announce_attrib",
            AnnounceNumber = "announce_number",
            SelectBattlecmd = "select_battlecmd",
            SelectCard = "select_card",
            SelectChain = "select_chain",
            SelectDisfield = "select_disfield",
            SelectEffectyn = "select_effectyn",
            SelectIdlecmd = "select_idlecmd",
            SelectOption = "select_option",
            SelectPlace = "select_place",
            SelectPosition = "select_position",
            SelectSum = "select_sum",
            SelectTribute = "select_tribute",
            SelectUnselectCard = "select_unselect_card",
            SelectYesno = "select_yesno",
            }
            interface ActionMsg {
            data: ActionMsgData;
            name: ActionMsgName;
            }
            export function convertActionMsg(msg: ygopro.StocGameMessage): ActionMsg {
            if (msg instanceof GM.MsgSelectCard) {
            return {
            name: ActionMsgName.SelectCard,
            data: convertMsgSelectCard(msg),
            };
            } else if (msg instanceof GM.MsgSelectTribute) {
            return {
            name: ActionMsgName.SelectTribute,
            data: convertMsgSelectTribute(msg),
            };
            } else if (msg instanceof GM.MsgSelectSum) {
            return {
            name: ActionMsgName.SelectSum,
            data: convertMsgSelectSum(msg),
            };
            } else if (msg instanceof GM.MsgSelectIdleCmd) {
            return {
            name: ActionMsgName.SelectIdlecmd,
            data: convertMsgSelectIdleCmd(msg),
            };
            } else if (msg instanceof GM.MsgSelectChain) {
            return {
            name: ActionMsgName.SelectChain,
            data: convertMsgSelectChain(msg),
            };
            } else if (msg instanceof GM.MsgSelectPosition) {
            return {
            name: ActionMsgName.SelectPosition,
            data: convertMsgSelectPosition(msg),
            };
            } else if (msg instanceof GM.MsgSelectEffectYn) {
            return {
            name: ActionMsgName.SelectEffectyn,
            data: convertMsgSelectEffectYn(msg),
            };
            } else if (msg instanceof GM.MsgSelectYesNo) {
            return {
            name: ActionMsgName.SelectYesno,
            data: convertMsgSelectYesNo(msg),
            };
            } else if (msg instanceof GM.MsgSelectBattleCmd) {
            return {
            name: ActionMsgName.SelectBattlecmd,
            data: convertMsgSelectBattleCmd(msg),
            };
            } else if (msg instanceof GM.MsgSelectUnselectCard) {
            return {
            name: ActionMsgName.SelectUnselectCard,
            data: convertMsgSelectUnselectCard(msg),
            };
            } else if (msg instanceof GM.MsgSelectOption) {
            return {
            name: ActionMsgName.SelectOption,
            data: convertMsgSelectOption(msg),
            };
            } else if (msg instanceof GM.MsgSelectPlace) {
            return {
            name: ActionMsgName.SelectPlace,
            data: convertMsgSelectPlace(msg),
            };
            } else if (msg instanceof GM.MsgAnnounce) {
            if (msg.announce_type == GM.MsgAnnounce.AnnounceType.Attribute) {
            return {
            name: ActionMsgName.AnnounceAttrib,
            data: convertMsgAnnounceAttrib(msg),
            };
            } else if (msg.announce_type == GM.MsgAnnounce.AnnounceType.Number) {
            return {
            name: ActionMsgName.AnnounceNumber,
            data: convertMsgAnnounceNumber(msg),
            };
            } else {
            throw new Error(`Unsupported announce type: ${msg.announce_type}`);
            }
            } else {
            throw new Error(`Unsupported message type: ${msg}`);
            }
            }
            export interface Input {
            action_msg: ActionMsg;
            cards: Card[];
            global: Global;
            }
            /**
            * MsgResponse
            */
            ......
            src/service/duel/agent.ts
            View file @ 2d1ca98c
            import { PredictReq, ygopro } from "@/api";
            import { cardStore, matStore, placeStore } from "@/stores";
            import { cardStore, matStore } from "@/stores";
            import { Global, convertPhase, convertCard, parsePlayerFromMsg, convertActionMsg, Input } from "@/api/ygoAgent/schema";
            export function genPredictReq(msg: ygopro.StocGameMessage): PredictReq {
            // 全局信息可以从 `matStore` 里面拿
            const mat = matStore;
            // 卡片信息可以从 `cardStore` 里面拿
            const cards = cardStore.inner;
            // 选择场上位置的可选项可以从 `cardStore` 里面拿
            // 也可以从 `selectPlace` msg 里面获取
            const place = placeStore;
            const zones = [
            ygopro.CardZone.DECK,
            ygopro.CardZone.HAND,
            ygopro.CardZone.MZONE,
            ygopro.CardZone.SZONE,
            ygopro.CardZone.GRAVE,
            ygopro.CardZone.REMOVED,
            ygopro.CardZone.EXTRA,
            ];
            // select_xxx msg 从参数 `msg` 里获取
            // 这里已经保证 `msg` 是众多 `select_xxx` msg 中的一个
            const duelId = mat.duelId;
            const index = mat.agentIndex;
            const player = parsePlayerFromMsg(msg);
            // TODO (ygo-agent): check if this is correct
            const opponent = 1 - player;
            const cards = cardStore.inner
            .filter((card) => zones.includes(card.location.zone))
            .map((card) => convertCard(card, player));
            const turnPlayer = mat.currentPlayer;
            const global: Global = {
            is_first: player === 0,
            is_my_turn: turnPlayer === player,
            my_lp: mat.initInfo.of(player).life,
            op_lp: mat.initInfo.of(opponent).life,
            phase: convertPhase(mat.phase.currentPhase),
            // TODO (ygo-agent): use real turn
            turn: 1,
            }
            const actionMsg = convertActionMsg(msg);
            const input: Input = {
            global: global,
            cards: cards,
            action_msg: actionMsg,
            }
            // TODO: impl
            return {
            index: mat.agentIndex,
            input: input,
            // TODO (ygo-agent): use real value
            prev_action_idx: 0,
            }
            }
            src/service/duel/gameMsg.ts
            View file @ 2d1ca98c
            import { ygopro } from "@/api";
            import { replayStore } from "@/stores";
            import { matStore, replayStore } from "@/stores";
            import { showWaiting } from "@/ui/Duel/Message";
            import onAnnounce from "./announce";
            ......@@ -100,6 +100,63 @@ export default async function handleGameMsg(
            if (replayStore.isReplay && ReplayIgnoreMsg.includes(msg.gameMsg)) return;
            switch (msg.gameMsg) {
            case "select_card": {
            matStore.actionMsg = msg.select_card;
            break;
            }
            case "select_tribute": {
            matStore.actionMsg = msg.select_tribute;
            break;
            }
            case "select_sum": {
            matStore.actionMsg = msg.select_sum;
            break;
            }
            case "select_idle_cmd": {
            matStore.actionMsg = msg.select_idle_cmd;
            break;
            }
            case "select_chain": {
            matStore.actionMsg = msg.select_chain;
            break;
            }
            case "select_position": {
            matStore.actionMsg = msg.select_position;
            break;
            }
            case "select_effect_yn": {
            matStore.actionMsg = msg.select_effect_yn;
            break;
            }
            case "select_yes_no": {
            matStore.actionMsg = msg.select_yes_no;
            break;
            }
            case "select_battle_cmd": {
            matStore.actionMsg = msg.select_battle_cmd;
            break;
            }
            case "select_unselect_card": {
            matStore.actionMsg = msg.select_unselect_card;
            break;
            }
            case "select_option": {
            matStore.actionMsg = msg.select_option;
            break;
            }
            case "select_place": {
            matStore.actionMsg = msg.select_place;
            break;
            }
            case "announce":
            matStore.actionMsg = msg.announce;
            break;
            default: {
            break;
            }
            }
            switch (msg.gameMsg) {
            case "start": {
            await onMsgStart(msg.start);
            ......
            src/stores/matStore/store.ts
            View file @ 2d1ca98c
            ......@@ -94,7 +94,8 @@ const initialState: Omit<MatState, "reset"> = {
            // methods
            isMe,
            duelId: "",
            agentIndex: 0
            agentIndex: 0,
            actionMsg: undefined
            };
            class MatStore implements MatState, NeosStore {
            ......@@ -113,6 +114,7 @@ class MatStore implements MatState, NeosStore {
            duelEnd = initialState.duelEnd;
            duelId = initialState.duelId;
            agentIndex = initialState.agentIndex;
            actionMsg = initialState.actionMsg;
            // methods
            isMe = initialState.isMe;
            ......
            src/stores/matStore/types.ts
            View file @ 2d1ca98c
            ......@@ -52,6 +52,7 @@ export interface MatState {
            duelId: string;
            agentIndex: number;
            actionMsg?: any;
            }
            export interface InitInfo {
            ......
            src/ui/Duel/PlayMat/Menu/index.tsx
            View file @ 2d1ca98c
            ......@@ -4,6 +4,7 @@ import {
            CloseCircleFilled,
            MessageFilled,
            StepForwardFilled,
            RobotFilled,
            } from "@ant-design/icons";
            import {
            Button,
            ......@@ -28,6 +29,8 @@ import {
            } from "@/api";
            import { ChainSetting, matStore } from "@/stores";
            import { IconFont } from "@/ui/Shared";
            import { predictDuel } from "@/api/ygoAgent/predict";
            import { genPredictReq } from "@/service/duel/agent";
            import styles from "./index.module.scss";
            import PhaseType = ygopro.StocGameMessage.MsgNewPhase.PhaseType;
            ......@@ -297,6 +300,15 @@ export const Menu = () => {
            const globalDisable = !matStore.isMe(currentPlayer);
            const aiPredict = async () => {
            console.log("AI Predict");
            const req = genPredictReq(matStore.actionMsg);
            console.log(req);
            const duelId = matStore.duelId;
            const predictRes = await predictDuel(duelId, req);
            console.log(predictRes);
            };
            return (
            <div className={styles["menu-container"]}>
            <SelectManager />
            ......@@ -323,6 +335,13 @@ export const Menu = () => {
            type="text"
            ></Button>
            </DropdownWithTitle>
            <Tooltip title="AI">
            <Button
            icon={<RobotFilled />}
            onClick={aiPredict}
            type="text"
            ></Button>
            </Tooltip>
            <Tooltip title={i18n("ChatRoom")}>
            <Button
            icon={<MessageFilled />}
            ......
            Markdown is supported
            0% or
            You are about to add 0 people to the discussion. Proceed with caution.
            Finish editing this message first!
            Please register or to comment