ygocore-interface/src/coremsg.ts

[WIP] ygocore interface (message definitions, constants, api signatures)

export type Optional<T> = T | undefined;

class BufferReader {
  constructor(
    private buffer: Buffer,
    private off: number = 0
  ) { }

  nextI8() {
    return this.buffer.readInt8(this.off++);
  }

  nextU8() {
    return this.buffer.readUInt8(this.off++);
  }

  nextI16() {
    return this.buffer.readInt16LE((this.off += 2) - 2);
  }

  nextU16() {
    return this.buffer.readUInt16LE((this.off += 2) - 2);
  }

  nextI32() {
    return this.buffer.readInt32LE((this.off += 4) - 4);
  }

  nextU32() {
    return this.buffer.readUInt32LE((this.off += 4) - 4);
  }

  finished() {
    return this.off >= this.buffer.length;
  }
}

export interface MsgRetry {
  msgtype: 'MSG_RETRY';
}

export interface MsgHint {
  msgtype: 'MSG_HINT';
  type: number;
  player: number;
  data: number;
}

export interface MsgWin {
  msgtype: 'MSG_WIN';
  player: number;
  type: number;
}

export interface MsgWaiting {
  msgtype: 'MSG_WAITING';
}

export interface MsgStart {
  msgtype: 'MSG_START';
  player_type: number;
  start_lp: Array<number>;
  deck_count: Array<{
    main_deck: number;
    extra_deck: number;
  }>;
}

export interface MsgUpdateData {
  msgtype: 'MSG_UPDATE_DATA';
  player: number;
  location: number;
  cards: Array<{
    query_flag: number;
    code: Optional<number>;
    info: Optional<{
      controller: number;
      location: number;
      position: number;
      sequence: number;
    }>;
    alias: Optional<number>;
    type: Optional<number>;
    level: Optional<number>;
    rank: Optional<number>;
    attribute: Optional<number>;
    race: Optional<number>;
    attack: Optional<number>;
    defense: Optional<number>;
    base_attack: Optional<number>;
    base_defense: Optional<number>;
    reason: Optional<number>;
    reason_card: Optional<{
      controller: number;
      location: number;
      position: number;
      sequence: number;
    }>;
    equip_card: Optional<{
      controller: number;
      location: number;
      position: number;
      sequence: number;
    }>;
    target_cards: Array<{
      controller: number;
      location: number;
      position: number;
      sequence: number;
    }>;
    overlay_cards: Array<number>;
    counters: Array<{
      type: number;
      count: number;
    }>;
    owner: Optional<number>;
    status: Optional<number>;
    lscale: Optional<number>;
    rscale: Optional<number>;
    link: Optional<number>;
    link_marker: Optional<number>;
  }>;
}

export interface MsgUpdateCard {
  msgtype: 'MSG_UPDATE_CARD';
  player: number;
  location: number;
  sequence: number;
  query_flag: number;
  code: Optional<number>;
  alias: Optional<number>;
  info: Optional<{
    controller: number;
    location: number;
    position: number;
    sequence: number;
  }>;
  type: Optional<number>;
  level: Optional<number>;
  rank: Optional<number>;
  attribute: Optional<number>;
  race: Optional<number>;
  attack: Optional<number>;
  defense: Optional<number>;
  base_attack: Optional<number>;
  base_defense: Optional<number>;
  reason: Optional<number>;
  reason_card: Optional<{
    controller: number;
    location: number;
    position: number;
    sequence: number;
  }>;
  equip_card: Optional<{
    controller: number;
    location: number;
    position: number;
    sequence: number;
  }>;
  target_cards: Array<{
    controller: number;
    location: number;
    position: number;
    sequence: number;
  }>;
  overlay_cards: Array<number>;
  counters: Array<{
    type: number;
    count: number;
  }>;
  owner: Optional<number>;
  status: Optional<number>;
  lscale: Optional<number>;
  rscale: Optional<number>;
  link: Optional<number>;
  link_marker: Optional<number>;
}

export interface MsgSelectBattleCmd {
  msgtype: 'MSG_SELECT_BATTLECMD';
  player: number;
  activatable: Array<{
    code_and_flags: number;
    controller: number;
    location: number;
    sequence: number;
    description: number;
  }>;
  attackable: Array<{
    code: number;
    controller: number;
    location: number;
    sequence: number;
    directly: number;
  }>;
  to_main_phase2: number;
  to_end_phase: number;
}

export interface MsgSelectIdleCmd {
  msgtype: 'MSG_SELECT_IDLECMD';
  player: number;
  summonables: Array<{
    code: number;
    controller: number;
    location: number;
    sequence: number;
  }>;
  special_summonables: Array<{
    code: number;
    controller: number;
    location: number;
    sequence: number;
  }>;
  reposables: Array<{
    code: number;
    controller: number;
    location: number;
    sequence: number;
  }>;
  setable_monsters: Array<{
    code: number;
    controller: number;
    location: number;
    sequence: number;
  }>;
  setable_spells: Array<{
    code: number;
    controller: number;
    location: number;
    sequence: number;
  }>;
  activatables: Array<{
    code: number;
    controller: number;
    location: number;
    sequence: number;
    description: number;
  }>;
  to_battle_phase: number;
  to_end_phase: number;
  shuffle_hand: number;
}

export interface MsgSelectEffectyn {
  msgtype: 'MSG_SELECT_EFFECTYN';
  player: number;
  code: number;
  controller: number;
  location: number;
  sequence: number;
  ignore: number;
  desc: number;
}

export interface MsgSelectYesno {
  msgtype: 'MSG_SELECT_YESNO';
  player: number;
  desc: number;
}

export interface MsgSelectOption {
  msgtype: 'MSG_SELECT_OPTION';
  player: number;
  options: Array<number>;
}

export interface MsgSelectCard {
  msgtype: 'MSG_SELECT_CARD';
  player: number;
  non_cancelable: number;
  range: {
    minimal: number;
    maximal: number;
  };
  selections: Array<{
    code: number;
    controller: number;
    location: number;
    sequence: number;
    subsequence: number;
  }>;
}

export interface MsgSelectUnselectCard {
  msgtype: 'MSG_SELECT_UNSELECT_CARD';
  player: number;
  should_continue: number;
  non_cancelable: number;
  range: {
    minimal: number;
    maximal: number;
  };
  not_selected: Array<{
    code: number;
    controller: number;
    location: number;
    sequence: number;
    subsequence: number;
  }>;
  selected: Array<{
    code: number;
    controller: number;
    location: number;
    sequence: number;
    subsequence: number;
  }>;
}

export interface MsgSelectChain {
  msgtype: 'MSG_SELECT_CHAIN';
  player: number;
  c1: number;
  spe_count: number;
  forced: number;
  hint0: number;
  hint1: number;
  activatables: Array<{
    flag: number;
    code: number;
    controller: number;
    location: number;
    sequence: number;
    subsequence: number;
    desc: number;
  }>;
}

export interface MsgSelectPlace {
  msgtype: 'MSG_SELECT_PLACE';
  player: number;
  minimal_selection: number;
  pattern: number;
}

export interface MsgSelectDisfield {
  msgtype: 'MSG_SELECT_DISFIELD';
  player: number;
  minimal_selection: number;
  pattern: number;
}

export interface MsgSelectPosition {
  msgtype: 'MSG_SELECT_POSITION';
  player: number;
  code: number;
  positions: number;
}

export interface MsgSelectTribute {
  msgtype: 'MSG_SELECT_TRIBUTE';
  player: number;
  non_cancelable: number;
  range: {
    minimal: number;
    maximal: number;
  };
  selections: Array<{
    code: number;
    controller: number;
    location: number;
    sequence: number;
    operation_param: number;
  }>;
}

export interface MsgSelectCounter {
  msgtype: 'MSG_SELECT_COUNTER';
  player: number;
  type: number;
  count: number;
  selections: Array<{
    code: number;
    controller: number;
    location: number;
    sequence: number;
    operation_param: number;
  }>;
}

export interface MsgSelectSum {
  msgtype: 'MSG_SELECT_SUM';
  select_mode: number;
  player: number;
  sum_up_to: number;
  range: {
    minimal: number;
    maximal: number;
  };
  includes: Array<{
    code: number;
    controller: number;
    location: number;
    sequence: number;
    value: number;
  }>;
  optionals: Array<{
    code: number;
    controller: number;
    location: number;
    sequence: number;
    value: number;
  }>;
}

export interface MsgSortCard {
  msgtype: 'MSG_SORT_CARD';
  player: number;
  selection: Array<{
    code: number;
    controller: number;
    location: number;
    sequence: number;
  }>;
}

export interface MsgSortChain {
  msgtype: 'MSG_SORT_CHAIN';
  player: number;
  selection: Array<{
    code: number;
    controller: number;
    location: number;
    sequence: number;
  }>;
}

export interface MsgConfirmDeckTop {
  msgtype: 'MSG_CONFIRM_DECKTOP';
  player: number;
  cards: Array<{
    code: number;
    controller: number;
    location: number;
    sequence: number;
  }>;
}

export interface MsgConfirmExtratop {
  msgtype: 'MSG_CONFIRM_EXTRATOP';
  player: number;
  cards: Array<{
    code: number;
    controller: number;
    location: number;
    sequence: number;
  }>;
}

export interface MsgConfirmCards {
  msgtype: 'MSG_CONFIRM_CARDS';
  player: number;
  cards: Array<{
    code: number;
    controller: number;
    location: number;
    sequence: number;
  }>;
}

export interface MsgShuffleDeck {
  msgtype: 'MSG_SHUFFLE_DECK';
  player: number;
}

export interface MsgRefreshDeck {
  msgtype: 'MSG_REFRESH_DECK';
  player: number;
}

export interface MsgSwapGraveDeck {
  msgtype: 'MSG_SWAP_GRAVE_DECK';
  player: number;
}

export interface MsgNewTurn {
  msgtype: 'MSG_NEW_TURN';
  player: number;
}

export interface MsgShuffleHand {
  msgtype: 'MSG_SHUFFLE_HAND';
  player: number;
  cards: Array<number>;
}

export interface MsgShuffleExtra {
  msgtype: 'MSG_SHUFFLE_EXTRA';
  player: number;
  cards: Array<number>;
}

export interface MsgDraw {
  msgtype: 'MSG_DRAW';
  player: number;
  cards: Array<number>;
}

export interface MsgReverseDeck {
  msgtype: 'MSG_REVERSE_DECK';
}

export interface MsgDeckTop {
  msgtype: 'MSG_DECK_TOP';
  player: number;
  sequence: number;
  code: number;
}

export interface MsgShuffleSetCard {
  msgtype: 'MSG_SHUFFLE_SET_CARD';
  location: number;
  c1: number;
  pass1: Array<{
    controller: number;
    location: number;
    sequence: number;
    ignore: number;
  }>;
  pass2: Array<{
    controller: number;
    location: number;
    sequence: number;
    ignore: number;
  }>;
}

export interface MsgNewPhase {
  msgtype: 'MSG_NEW_PHASE';
  phase: number;
}

export interface MsgMove {
  msgtype: 'MSG_MOVE';
  code: number;
  previous: {
    controller: number;
    location: number;
    sequence: number;
    position: number;
  };
  current: {
    controller: number;
    location: number;
    sequence: number;
    position: number;
  };
  reason: number;
}

export interface MsgPosChange {
  msgtype: 'MSG_POS_CHANGE';
  code: number;
  current_controller: number;
  current_location: number;
  current_sequence: number;
  previous_position: number;
  current_position: number;
}

export interface MsgSet {
  msgtype: 'MSG_SET';
  code: number;
  controller: number;
  location: number;
  sequence: number;
  position: number;
}

export interface MsgSwap {
  msgtype: 'MSG_SWAP';
  first: {
    code: number;
    controller: number;
    location: number;
    sequence: number;
    position: number;
  };
  second: {
    code: number;
    controller: number;
    location: number;
    sequence: number;
    position: number;
  };
}

export interface MsgFieldDisabled {
  msgtype: 'MSG_FIELD_DISABLED';
  pattern: number;
}

export interface MsgSummoning {
  msgtype: 'MSG_SUMMONING';
  code: number;
  controller: number;
  location: number;
  sequence: number;
  position: number;
}

export interface MsgSpsummoning {
  msgtype: 'MSG_SPSUMMONING';
  code: number;
  controller: number;
  location: number;
  sequence: number;
  position: number;
}

export interface MsgFlipsummoning {
  msgtype: 'MSG_FLIPSUMMONING';
  code: number;
  controller: number;
  location: number;
  sequence: number;
  position: number;
}

export interface MsgSummoned {
  msgtype: 'MSG_SUMMONED';
}

export interface MsgSpsummoned {
  msgtype: 'MSG_SPSUMMONED';
}

export interface MsgFlipsummoned {
  msgtype: 'MSG_FLIPSUMMONED';
}

export interface MsgChaining {
  msgtype: 'MSG_CHAINING';
  code: number;
  previous_controller: number;
  previous_location: number;
  previous_sequence: number;
  subsequence: number;
  controller: number;
  location: number;
  sequence: number;
  desc: number;
  param: number;
}

export interface MsgChained {
  msgtype: 'MSG_CHAINED';
  param: number;
}

export interface MsgChainSolving {
  msgtype: 'MSG_CHAIN_SOLVING';
  param: number;
}

export interface MsgChainSolved {
  msgtype: 'MSG_CHAIN_SOLVED';
  param: number;
}

export interface MsgChainNegated {
  msgtype: 'MSG_CHAIN_NEGATED';
  param: number;
}

export interface MsgChainDisabled {
  msgtype: 'MSG_CHAIN_DISABLED';
  param: number;
}

export interface MsgChainEnd {
  msgtype: 'MSG_CHAIN_END';
}

export interface MsgCardSelected {
  msgtype: 'MSG_CARD_SELECTED';
}

export interface MsgBecomeTarget {
  msgtype: 'MSG_BECOME_TARGET';
  cards: Array<{
    controller: number;
    location: number;
    sequence: number;
    subsequence: number;
  }>;
}

export interface MsgRandomSelected {
  msgtype: 'MSG_RANDOM_SELECTED';
  player: number;
  cards: Array<{
    controller: number;
    location: number;
    sequence: number;
    subsequence: number;
  }>;
}

export interface MsgDamage {
  msgtype: 'MSG_DAMAGE';
  player: number;
  value: number;
}

export interface MsgRecover {
  msgtype: 'MSG_RECOVER';
  player: number;
  value: number;
}

export interface MsgLpUpdate {
  msgtype: 'MSG_LPUPDATE';
  player: number;
  value: number;
}

export interface MsgPayLpCost {
  msgtype: 'MSG_PAY_LPCOST';
  player: number;
  value: number;
}

export interface MsgEquip {
  msgtype: 'MSG_EQUIP';
  card: {
    controller: number;
    location: number;
    sequence: number;
    ignore: number;
  };
  target: {
    controller: number;
    location: number;
    sequence: number;
    ignore: number;
  };
}

export interface MsgCardTarget {
  msgtype: 'MSG_CARD_TARGET';
  card: {
    controller: number;
    location: number;
    sequence: number;
    ignore: number;
  };
  target: {
    controller: number;
    location: number;
    sequence: number;
    ignore: number;
  };
}

export interface MsgCancelTarget {
  msgtype: 'MSG_CANCEL_TARGET';
  card: {
    controller: number;
    location: number;
    sequence: number;
    ignore: number;
  };
  target: {
    controller: number;
    location: number;
    sequence: number;
    ignore: number;
  };
}

export interface MsgUnequip {
  msgtype: 'MSG_UNEQUIP';
  controller: number;
  location: number;
  sequence: number;
  ignore: number;
}

export interface MsgAddCounter {
  msgtype: 'MSG_ADD_COUNTER';
  type: number;
  controller: number;
  location: number;
  sequence: number;
  count: number;
}

export interface MsgRemoveCounter {
  msgtype: 'MSG_REMOVE_COUNTER';
  type: number;
  controller: number;
  location: number;
  sequence: number;
  count: number;
}

export interface MsgAttack {
  msgtype: 'MSG_ATTACK';
  attacker: {
    controller: number;
    location: number;
    sequence: number;
    ignore: number;
  };
  defender: {
    controller: number;
    location: number;
    sequence: number;
    ignore: number;
  };
}

export interface MsgBattle {
  msgtype: 'MSG_BATTLE';
  attacker: {
    controller: number;
    location: number;
    sequence: number;
    subsequence: number;
    atkvalue: number;
    defvalue: number;
    ignore: number;
  };
  defender: {
    controller: number;
    location: number;
    sequence: number;
    subsequence: number;
    atkvalue: number;
    defvalue: number;
    ignore: number;
  };
}

export interface MsgAttackDisabled {
  msgtype: 'MSG_ATTACK_DISABLED';
}

export interface MsgDamageStepStart {
  msgtype: 'MSG_DAMAGE_STEP_START';
}

export interface MsgDamageStepEnd {
  msgtype: 'MSG_DAMAGE_STEP_END';
}

export interface MsgMissedEffect {
  msgtype: 'MSG_MISSED_EFFECT';
  controller: number;
  location: number;
  sequence: number;
  subsequence: number;
  code: number;
}

export interface MsgTossCoin {
  msgtype: 'MSG_TOSS_COIN';
  player: number;
  tosses: Array<number>;
}

export interface MsgTossDice {
  msgtype: 'MSG_TOSS_DICE';
  player: number;
  tosses: Array<number>;
}

export interface MsgRockPaperScissors {
  msgtype: 'MSG_ROCK_PAPER_SCISSORS';
  player: number;
}

export interface MsgHandRes {
  msgtype: 'MSG_HAND_RES';
  result: number;
}

export interface MsgAnnounceRace {
  msgtype: 'MSG_ANNOUNCE_RACE';
  player: number;
  count: number;
  available: number;
}

export interface MsgAnnounceAttrib {
  msgtype: 'MSG_ANNOUNCE_ATTRIB';
  player: number;
  count: number;
  available: number;
}

export interface MsgAnnounceCard {
  msgtype: 'MSG_ANNOUNCE_CARD';
  player: number;
  declarable_type: number;
}

export interface MsgAnnounceNumber {
  msgtype: 'MSG_ANNOUNCE_NUMBER';
  player: number;
  announcements: Array<number>;
}

export interface MsgAnnounceCardFilter {
  msgtype: 'MSG_ANNOUNCE_CARD_FILTER';
  player: number;
  announcements: Array<number>;
}

export interface MsgCardHint {
  msgtype: 'MSG_CARD_HINT';
  controller: number;
  location: number;
  sequence: number;
  ignore: number;
  chtype: number;
  value: number;
}

export interface MsgPlayerHint {
  msgtype: 'MSG_PLAYER_HINT';
  player: number;
  chtype: number;
  value: number;
}

export interface MsgMatchKill {
  msgtype: 'MSG_MATCH_KILL';
  match_kill: number;
}

export interface MsgTagSwap {
  msgtype: 'MSG_TAG_SWAP';
  player: number;
  m: number;
  e: number;
  p: number;
  h: number;
}

export interface MsgReloadField {
  msgtype: 'MSG_RELOAD_FIELD';
  duel_rule: number;
  players: Array<{
    lp: number;
    mzone_cards: Array<Optional<{
      position: number;
      xyz_count: number;
    }>>;
    card_positions: Array<Optional<number>>;
    deck_count: number;
    hand_count: number;
    grave_count: number;
    banish_count: number;
    extra_count: number;
    extra_pendu_count: number;
    chains: Array<{
      code: number;
      previous_controller: number;
      previous_location: number;
      previous_sequence: number;
      previous_subsequence: number;
      current_controller: number;
      current_location: number;
      current_sequence: number;
      desc: number;
    }>;
  }>;
}
/**
 * message type
 */
export type Message = MsgRetry
                    | MsgHint
                    | MsgWin
                    | MsgWaiting
                    | MsgStart
                    | MsgUpdateData
                    | MsgUpdateCard
                    | MsgSelectBattleCmd
                    | MsgSelectIdleCmd
                    | MsgSelectEffectyn
                    | MsgSelectYesno
                    | MsgSelectOption
                    | MsgSelectCard
                    | MsgSelectUnselectCard
                    | MsgSelectChain
                    | MsgSelectPlace
                    | MsgSelectDisfield
                    | MsgSelectPosition
                    | MsgSelectTribute
                    | MsgSelectCounter
                    | MsgSelectSum
                    | MsgSortCard
                    | MsgSortChain
                    | MsgConfirmDeckTop
                    | MsgConfirmExtratop
                    | MsgConfirmCards
                    | MsgShuffleDeck
                    | MsgRefreshDeck
                    | MsgSwapGraveDeck
                    | MsgNewTurn
                    | MsgShuffleHand
                    | MsgShuffleExtra
                    | MsgDraw
                    | MsgReverseDeck
                    | MsgDeckTop
                    | MsgShuffleSetCard
                    | MsgNewPhase
                    | MsgMove
                    | MsgPosChange
                    | MsgSet
                    | MsgSwap
                    | MsgFieldDisabled
                    | MsgSummoning
                    | MsgSpsummoning
                    | MsgFlipsummoning
                    | MsgSummoned
                    | MsgSpsummoned
                    | MsgFlipsummoned
                    | MsgChaining
                    | MsgChained
                    | MsgChainSolving
                    | MsgChainSolved
                    | MsgChainNegated
                    | MsgChainDisabled
                    | MsgChainEnd
                    | MsgCardSelected
                    | MsgBecomeTarget
                    | MsgRandomSelected
                    | MsgDamage
                    | MsgRecover
                    | MsgLpUpdate
                    | MsgPayLpCost
                    | MsgEquip
                    | MsgCardTarget
                    | MsgCancelTarget
                    | MsgUnequip
                    | MsgAddCounter
                    | MsgRemoveCounter
                    | MsgAttack
                    | MsgBattle
                    | MsgAttackDisabled
                    | MsgDamageStepStart
                    | MsgDamageStepEnd
                    | MsgMissedEffect
                    | MsgTossCoin
                    | MsgTossDice
                    | MsgRockPaperScissors
                    | MsgHandRes
                    | MsgAnnounceRace
                    | MsgAnnounceAttrib
                    | MsgAnnounceCard
                    | MsgAnnounceNumber
                    | MsgAnnounceCardFilter
                    | MsgCardHint
                    | MsgPlayerHint
                    | MsgMatchKill
                    | MsgTagSwap
                    | MsgReloadField
                    ;

/**
 * parse bytes as MsgRetry (MSG_RETRY)
 */
function parseMsgRetry(_buffer: BufferReader): MsgRetry {
  const result: any = { };
  { /* reading result (MsgRetry) */
  }
  result.msgtype = 'MSG_RETRY';
  return result as MsgRetry;
}

/**
 * parse bytes as MsgHint (MSG_HINT)
 */
function parseMsgHint(buffer: BufferReader): MsgHint {
  const result: any = { };
  { /* reading result (MsgHint) */
    result.type = buffer.nextI8();
    result.player = buffer.nextU8();
    result.data = buffer.nextI32();
  }
  result.msgtype = 'MSG_HINT';
  return result as MsgHint;
}

/**
 * parse bytes as MsgWin (MSG_WIN)
 */
function parseMsgWin(buffer: BufferReader): MsgWin {
  const result: any = { };
  { /* reading result (MsgWin) */
    result.player = buffer.nextU8();
    result.type = buffer.nextI8();
  }
  result.msgtype = 'MSG_WIN';
  return result as MsgWin;
}

/**
 * parse bytes as MsgWaiting (MSG_WAITING)
 */
function parseMsgWaiting(_buffer: BufferReader): MsgWaiting {
  const result: any = { };
  { /* reading result (MsgWaiting) */
  }
  result.msgtype = 'MSG_WAITING';
  return result as MsgWaiting;
}

/**
 * parse bytes as MsgStart (MSG_START)
 */
function parseMsgStart(buffer: BufferReader): MsgStart {
  const result: any = { };
  { /* reading result (MsgStart) */
    result.player_type = buffer.nextU8();
    const start_lp: any[] = [];
    for (let i = 0; i !== 2; ++i) {
      const start_lp1 = buffer.nextI32();
      start_lp.push(start_lp1);
    }
    result.start_lp = start_lp;
    const deck_count: any[] = [];
    for (let i = 0; i !== 2; ++i) {
      const deck_count1: any = { };
      { /* reading deck_count1 (DeckCount) */
        deck_count1.main_deck = buffer.nextI16();
        deck_count1.extra_deck = buffer.nextI16();
      }
      deck_count.push(deck_count1);
    }
    result.deck_count = deck_count;
  }
  result.msgtype = 'MSG_START';
  return result as MsgStart;
}

/**
 * returned from `query_card()`
 */
export interface QueryCardChunk {
  query_flag: number;
  code: Optional<number>;
  info: Optional<{
    controller: number;
    location: number;
    position: number;
    sequence: number;
  }>;
  alias: Optional<number>;
  type: Optional<number>;
  level: Optional<number>;
  rank: Optional<number>;
  attribute: Optional<number>;
  race: Optional<number>;
  attack: Optional<number>;
  defense: Optional<number>;
  base_attack: Optional<number>;
  base_defense: Optional<number>;
  reason: Optional<number>;
  reason_card: Optional<{
    controller: number;
    location: number;
    position: number;
    sequence: number;
  }>;
  equip_card: Optional<{
    controller: number;
    location: number;
    position: number;
    sequence: number;
  }>;
  target_cards: Array<{
    controller: number;
    location: number;
    position: number;
    sequence: number;
  }>;
  overlay_cards: Array<number>;
  counters: Array<{
    type: number;
    count: number;
  }>;
  owner: Optional<number>;
  status: Optional<number>;
  lscale: Optional<number>;
  rscale: Optional<number>;
  link: Optional<number>;
  link_marker: Optional<number>;
}

/* */
function parseInfoLocation(buffer: BufferReader): any {
  const info: any = { };
  info.controller = buffer.nextU8();
  info.location = buffer.nextU8();
  info.sequence = buffer.nextU8();
  info.position = buffer.nextU8();
  return info;
}

function parseInfoLocations(buffer: BufferReader): any {
  const many: any[] = [];
  const count = buffer.nextU32();
  for (let i = 0; i !== count; ++i) {
    many.push(parseInfoLocation(buffer));
  }
  return many;
}

function parseChunks(buffer: BufferReader): any[] {
  const chunks: any[] = [];
  while (!buffer.finished()) {
    const bytes = buffer.nextU32();
    if (bytes === 4) continue;

    const chunk: any = { };
    const flags = buffer.nextU32();

    chunk.query_flag = flags;
    if (flags & QUERY.CODE) chunk.code = buffer.nextU32();
    if (flags & QUERY.POSITION) chunk.info = parseInfoLocation(buffer);
    if (flags & QUERY.ALIAS) chunk.alias = buffer.nextU32();
    if (flags & QUERY.TYPE) chunk.type = buffer.nextU32();
    if (flags & QUERY.LEVEL) chunk.level = buffer.nextU32();
    if (flags & QUERY.RANK) chunk.rank = buffer.nextU32();
    if (flags & QUERY.ATTRIBUTE) chunk.attribute = buffer.nextU32();
    if (flags & QUERY.RACE) chunk.race = buffer.nextU32();
    if (flags & QUERY.ATTACK) chunk.attack = buffer.nextI32();
    if (flags & QUERY.DEFENSE) chunk.defense = buffer.nextI32();
    if (flags & QUERY.BASE_ATTACK) chunk.base_attack = buffer.nextI32();
    if (flags & QUERY.BASE_DEFENSE) chunk.base_defense = buffer.nextI32();
    if (flags & QUERY.REASON) chunk.reason = buffer.nextI32();

    if (flags & QUERY.REASON_CARD) chunk.reason_card = parseInfoLocation(buffer);
    if (flags & QUERY.EQUIP_CARD) chunk.equip_card = parseInfoLocation(buffer);
    if (flags & QUERY.TARGET_CARD) chunk.target_cards = parseInfoLocations(buffer);
    if (flags & QUERY.OVERLAY_CARD) {
      const count = buffer.nextU32();
      for (let i = 0; i !== count; ++i) chunk.overlay_cards.push(buffer.nextU32());
    }
    if (flags & QUERY.COUNTERS) {
      const count = buffer.nextU32();
      for (let i = 0; i !== count; ++i) {
        const type = buffer.nextU16();
        const count = buffer.nextU16();
        chunk.counters.push({ type, count });
      }
    }
    if (flags & QUERY.OWNER) chunk.owner = buffer.nextU32();
    if (flags & QUERY.STATUS) chunk.status = buffer.nextU32();
    if (flags & QUERY.LSCALE) chunk.lscale = buffer.nextU32();
    if (flags & QUERY.RSCALE) chunk.rscale = buffer.nextU32();

    if (flags & QUERY.LINK) chunk.link = buffer.nextU32();
    if (flags & QUERY.LINK) chunk.link_marker = buffer.nextU32();

    chunks.push(chunk);
  }

  return chunks;
}

/**
 * MSG_UPDATE_DATA
 */
function parseMsgUpdateData(buffer: BufferReader): MsgUpdateData {
  const result: any = { };
  result.msgtype = 'MSG_UPDATE_DATA';
  result.player = buffer.nextU8();
  result.location = buffer.nextU8();
  result.cards = parseChunks(buffer);

  return result as MsgUpdateData;
}

export function parseFieldCardQueryResult(buffer: Buffer): QueryCardChunk[] {
  return parseChunks(new BufferReader(buffer)) as QueryCardChunk[];
}

/**
 * MSG_UPDATE_CARD
 */
function parseMsgUpdateCard(buffer: BufferReader): MsgUpdateCard {
  const result: any = { };
  result.msgtype = 'MSG_UPDATE_CARD';

  result.player = buffer.nextU8();
  result.location = buffer.nextU8();
  result.sequence = buffer.nextU8();
  const chunk = parseChunks(buffer);
  return { ...result, ...chunk[0] } as MsgUpdateCard;
}

export function parseCardQueryResult(buffer: Buffer): QueryCardChunk {
  return parseChunks(new BufferReader(buffer))[0] as QueryCardChunk;
}

/**
 * parse bytes as MsgSelectBattleCmd (MSG_SELECT_BATTLECMD)
 */
function parseMsgSelectBattleCmd(buffer: BufferReader): MsgSelectBattleCmd {
  const result: any = { };
  { /* reading result (MsgSelectBattleCmd) */
    result.player = buffer.nextU8();
    const activatable: any[] = [];
    // tslint:disable-next-line:one-variable-per-declaration
    for (let i = 0, n = buffer.nextU8(); i !== n; ++i) {
      const activatable1: any = { };
      { /* reading activatable1 (Activatable) */
        activatable1.code_and_flags = buffer.nextU32();
        activatable1.controller = buffer.nextU8();
        activatable1.location = buffer.nextU8();
        activatable1.sequence = buffer.nextU8();
        activatable1.description = buffer.nextI32();
      }
      activatable.push(activatable1)
    }
    result.activatable = activatable;
    const attackable: any[] = [];
    // tslint:disable-next-line:one-variable-per-declaration
    for (let i = 0, n = buffer.nextU8(); i !== n; ++i) {
      const attackable1: any = { };
      { /* reading attackable1 (Attackable) */
        attackable1.code = buffer.nextU32();
        attackable1.controller = buffer.nextU8();
        attackable1.location = buffer.nextU8();
        attackable1.sequence = buffer.nextU8();
        attackable1.directly = buffer.nextI8();
      }
      attackable.push(attackable1)
    }
    result.attackable = attackable;
    result.to_main_phase2 = buffer.nextI8();
    result.to_end_phase = buffer.nextI8();
  }
  result.msgtype = 'MSG_SELECT_BATTLECMD';
  return result as MsgSelectBattleCmd;
}

/**
 * parse bytes as MsgSelectIdleCmd (MSG_SELECT_IDLECMD)
 */
function parseMsgSelectIdleCmd(buffer: BufferReader): MsgSelectIdleCmd {
  const result: any = { };
  { /* reading result (MsgSelectIdleCmd) */
    result.player = buffer.nextU8();
    const summonables: any[] = [];
    // tslint:disable-next-line:one-variable-per-declaration
    for (let i = 0, n = buffer.nextU8(); i !== n; ++i) {
      const summonables1: any = { };
      { /* reading summonables1 (IdleCommandSelection) */
        summonables1.code = buffer.nextU32();
        summonables1.controller = buffer.nextU8();
        summonables1.location = buffer.nextU8();
        summonables1.sequence = buffer.nextU8();
      }
      summonables.push(summonables1)
    }
    result.summonables = summonables;
    const special_summonables: any[] = [];
    // tslint:disable-next-line:one-variable-per-declaration
    for (let i = 0, n = buffer.nextU8(); i !== n; ++i) {
      const special_summonables1: any = { };
      { /* reading special_summonables1 (IdleCommandSelection) */
        special_summonables1.code = buffer.nextU32();
        special_summonables1.controller = buffer.nextU8();
        special_summonables1.location = buffer.nextU8();
        special_summonables1.sequence = buffer.nextU8();
      }
      special_summonables.push(special_summonables1)
    }
    result.special_summonables = special_summonables;
    const reposables: any[] = [];
    // tslint:disable-next-line:one-variable-per-declaration
    for (let i = 0, n = buffer.nextU8(); i !== n; ++i) {
      const reposables1: any = { };
      { /* reading reposables1 (IdleCommandSelection) */
        reposables1.code = buffer.nextU32();
        reposables1.controller = buffer.nextU8();
        reposables1.location = buffer.nextU8();
        reposables1.sequence = buffer.nextU8();
      }
      reposables.push(reposables1)
    }
    result.reposables = reposables;
    const setable_monsters: any[] = [];
    // tslint:disable-next-line:one-variable-per-declaration
    for (let i = 0, n = buffer.nextU8(); i !== n; ++i) {
      const setable_monsters1: any = { };
      { /* reading setable_monsters1 (IdleCommandSelection) */
        setable_monsters1.code = buffer.nextU32();
        setable_monsters1.controller = buffer.nextU8();
        setable_monsters1.location = buffer.nextU8();
        setable_monsters1.sequence = buffer.nextU8();
      }
      setable_monsters.push(setable_monsters1)
    }
    result.setable_monsters = setable_monsters;
    const setable_spells: any[] = [];
    // tslint:disable-next-line:one-variable-per-declaration
    for (let i = 0, n = buffer.nextU8(); i !== n; ++i) {
      const setable_spells1: any = { };
      { /* reading setable_spells1 (IdleCommandSelection) */
        setable_spells1.code = buffer.nextU32();
        setable_spells1.controller = buffer.nextU8();
        setable_spells1.location = buffer.nextU8();
        setable_spells1.sequence = buffer.nextU8();
      }
      setable_spells.push(setable_spells1)
    }
    result.setable_spells = setable_spells;
    const activatables: any[] = [];
    // tslint:disable-next-line:one-variable-per-declaration
    for (let i = 0, n = buffer.nextU8(); i !== n; ++i) {
      const activatables1: any = { };
      { /* reading activatables1 (Activatable) */
        activatables1.code = buffer.nextU32();
        activatables1.controller = buffer.nextU8();
        activatables1.location = buffer.nextU8();
        activatables1.sequence = buffer.nextU8();
        activatables1.description = buffer.nextI32();
      }
      activatables.push(activatables1)
    }
    result.activatables = activatables;
    result.to_battle_phase = buffer.nextI8();
    result.to_end_phase = buffer.nextI8();
    result.shuffle_hand = buffer.nextI8();
  }
  result.msgtype = 'MSG_SELECT_IDLECMD';
  return result as MsgSelectIdleCmd;
}

/**
 * parse bytes as MsgSelectEffectyn (MSG_SELECT_EFFECTYN)
 */
function parseMsgSelectEffectyn(buffer: BufferReader): MsgSelectEffectyn {
  const result: any = { };
  { /* reading result (MsgSelectEffectyn) */
    result.player = buffer.nextU8();
    result.code = buffer.nextU32();
    result.controller = buffer.nextU8();
    result.location = buffer.nextU8();
    result.sequence = buffer.nextU8();
    result.ignore = buffer.nextI8();
    result.desc = buffer.nextI32();
  }
  result.msgtype = 'MSG_SELECT_EFFECTYN';
  return result as MsgSelectEffectyn;
}

/**
 * parse bytes as MsgSelectYesno (MSG_SELECT_YESNO)
 */
function parseMsgSelectYesno(buffer: BufferReader): MsgSelectYesno {
  const result: any = { };
  { /* reading result (MsgSelectYesno) */
    result.player = buffer.nextU8();
    result.desc = buffer.nextI32();
  }
  result.msgtype = 'MSG_SELECT_YESNO';
  return result as MsgSelectYesno;
}

/**
 * parse bytes as MsgSelectOption (MSG_SELECT_OPTION)
 */
function parseMsgSelectOption(buffer: BufferReader): MsgSelectOption {
  const result: any = { };
  { /* reading result (MsgSelectOption) */
    result.player = buffer.nextU8();
    const options: any[] = [];
    // tslint:disable-next-line:one-variable-per-declaration
    for (let i = 0, n = buffer.nextU8(); i !== n; ++i) {
      const options1 = buffer.nextI32();
      options.push(options1)
    }
    result.options = options;
  }
  result.msgtype = 'MSG_SELECT_OPTION';
  return result as MsgSelectOption;
}

/**
 * parse bytes as MsgSelectCard (MSG_SELECT_CARD)
 */
function parseMsgSelectCard(buffer: BufferReader): MsgSelectCard {
  const result: any = { };
  { /* reading result (MsgSelectCard) */
    result.player = buffer.nextU8();
    result.non_cancelable = buffer.nextI8();
    const range: any = { };
    { /* reading range (Range) */
      range.minimal = buffer.nextI8();
      range.maximal = buffer.nextI8();
    }
    result.range = range;
    const selections: any[] = [];
    // tslint:disable-next-line:one-variable-per-declaration
    for (let i = 0, n = buffer.nextU8(); i !== n; ++i) {
      const selections1: any = { };
      { /* reading selections1 (Selection) */
        selections1.code = buffer.nextU32();
        selections1.controller = buffer.nextU8();
        selections1.location = buffer.nextU8();
        selections1.sequence = buffer.nextU8();
        selections1.subsequence = buffer.nextU8();
      }
      selections.push(selections1)
    }
    result.selections = selections;
  }
  result.msgtype = 'MSG_SELECT_CARD';
  return result as MsgSelectCard;
}

/**
 * parse bytes as MsgSelectUnselectCard (MSG_SELECT_UNSELECT_CARD)
 */
function parseMsgSelectUnselectCard(buffer: BufferReader): MsgSelectUnselectCard {
  const result: any = { };
  { /* reading result (MsgSelectUnselectCard) */
    result.player = buffer.nextU8();
    result.should_continue = buffer.nextI8();
    result.non_cancelable = buffer.nextI8();
    const range: any = { };
    { /* reading range (Range) */
      range.minimal = buffer.nextI8();
      range.maximal = buffer.nextI8();
    }
    result.range = range;
    const not_selected: any[] = [];
    // tslint:disable-next-line:one-variable-per-declaration
    for (let i = 0, n = buffer.nextU8(); i !== n; ++i) {
      const not_selected1: any = { };
      { /* reading not_selected1 (Selection) */
        not_selected1.code = buffer.nextU32();
        not_selected1.controller = buffer.nextU8();
        not_selected1.location = buffer.nextU8();
        not_selected1.sequence = buffer.nextU8();
        not_selected1.subsequence = buffer.nextU8();
      }
      not_selected.push(not_selected1)
    }
    result.not_selected = not_selected;
    const selected: any[] = [];
    // tslint:disable-next-line:one-variable-per-declaration
    for (let i = 0, n = buffer.nextU8(); i !== n; ++i) {
      const selected1: any = { };
      { /* reading selected1 (Selection) */
        selected1.code = buffer.nextU32();
        selected1.controller = buffer.nextU8();
        selected1.location = buffer.nextU8();
        selected1.sequence = buffer.nextU8();
        selected1.subsequence = buffer.nextU8();
      }
      selected.push(selected1)
    }
    result.selected = selected;
  }
  result.msgtype = 'MSG_SELECT_UNSELECT_CARD';
  return result as MsgSelectUnselectCard;
}

/**
 * parse bytes as MsgSelectChain (MSG_SELECT_CHAIN)
 */
function parseMsgSelectChain(buffer: BufferReader): MsgSelectChain {
  const result: any = { };
  { /* reading result (MsgSelectChain) */
    result.player = buffer.nextU8();
    const c1 = buffer.nextI8();
    /* c1: hidden */
    result.spe_count = buffer.nextI8();
    result.forced = buffer.nextI8();
    result.hint0 = buffer.nextI32();
    result.hint1 = buffer.nextI32();
    const activatables: any[] = [];
    // tslint:disable-next-line:one-variable-per-declaration
    for (let i = 0, n = c1; i !== n; ++i) {
      const activatables1: any = { };
      { /* reading activatables1 (Activatable) */
        activatables1.flag = buffer.nextI8();
        activatables1.code = buffer.nextU32();
        activatables1.controller = buffer.nextU8();
        activatables1.location = buffer.nextU8();
        activatables1.sequence = buffer.nextU8();
        activatables1.subsequence = buffer.nextU8();
        activatables1.desc = buffer.nextI32();
      }
      activatables.push(activatables1)
    }
    result.activatables = activatables;
  }
  result.msgtype = 'MSG_SELECT_CHAIN';
  return result as MsgSelectChain;
}

/**
 * parse bytes as MsgSelectPlace (MSG_SELECT_PLACE)
 */
function parseMsgSelectPlace(buffer: BufferReader): MsgSelectPlace {
  const result: any = { };
  { /* reading result (MsgSelectPlace) */
    result.player = buffer.nextU8();
    result.minimal_selection = buffer.nextI8();
    result.pattern = buffer.nextU32();
  }
  result.msgtype = 'MSG_SELECT_PLACE';
  return result as MsgSelectPlace;
}

/**
 * parse bytes as MsgSelectDisfield (MSG_SELECT_DISFIELD)
 */
function parseMsgSelectDisfield(buffer: BufferReader): MsgSelectDisfield {
  const result: any = { };
  { /* reading result (MsgSelectDisfield) */
    result.player = buffer.nextU8();
    result.minimal_selection = buffer.nextI8();
    result.pattern = buffer.nextU32();
  }
  result.msgtype = 'MSG_SELECT_DISFIELD';
  return result as MsgSelectDisfield;
}

/**
 * parse bytes as MsgSelectPosition (MSG_SELECT_POSITION)
 */
function parseMsgSelectPosition(buffer: BufferReader): MsgSelectPosition {
  const result: any = { };
  { /* reading result (MsgSelectPosition) */
    result.player = buffer.nextU8();
    result.code = buffer.nextU32();
    result.positions = buffer.nextU8();
  }
  result.msgtype = 'MSG_SELECT_POSITION';
  return result as MsgSelectPosition;
}

/**
 * parse bytes as MsgSelectTribute (MSG_SELECT_TRIBUTE)
 */
function parseMsgSelectTribute(buffer: BufferReader): MsgSelectTribute {
  const result: any = { };
  { /* reading result (MsgSelectTribute) */
    result.player = buffer.nextU8();
    result.non_cancelable = buffer.nextI8();
    const range: any = { };
    { /* reading range (Range) */
      range.minimal = buffer.nextI8();
      range.maximal = buffer.nextI8();
    }
    result.range = range;
    const selections: any[] = [];
    // tslint:disable-next-line:one-variable-per-declaration
    for (let i = 0, n = buffer.nextU8(); i !== n; ++i) {
      const selections1: any = { };
      { /* reading selections1 (Selection) */
        selections1.code = buffer.nextU32();
        selections1.controller = buffer.nextU8();
        selections1.location = buffer.nextU8();
        selections1.sequence = buffer.nextU8();
        selections1.operation_param = buffer.nextI8();
      }
      selections.push(selections1)
    }
    result.selections = selections;
  }
  result.msgtype = 'MSG_SELECT_TRIBUTE';
  return result as MsgSelectTribute;
}

/**
 * parse bytes as MsgSelectCounter (MSG_SELECT_COUNTER)
 */
function parseMsgSelectCounter(buffer: BufferReader): MsgSelectCounter {
  const result: any = { };
  { /* reading result (MsgSelectCounter) */
    result.player = buffer.nextU8();
    result.type = buffer.nextI16();
    result.count = buffer.nextI16();
    const selections: any[] = [];
    // tslint:disable-next-line:one-variable-per-declaration
    for (let i = 0, n = buffer.nextU8(); i !== n; ++i) {
      const selections1: any = { };
      { /* reading selections1 (Selection) */
        selections1.code = buffer.nextU32();
        selections1.controller = buffer.nextU8();
        selections1.location = buffer.nextU8();
        selections1.sequence = buffer.nextU8();
        selections1.operation_param = buffer.nextI16();
      }
      selections.push(selections1)
    }
    result.selections = selections;
  }
  result.msgtype = 'MSG_SELECT_COUNTER';
  return result as MsgSelectCounter;
}

/**
 * parse bytes as MsgSelectSum (MSG_SELECT_SUM)
 */
function parseMsgSelectSum(buffer: BufferReader): MsgSelectSum {
  const result: any = { };
  { /* reading result (MsgSelectSum) */
    result.select_mode = buffer.nextI8();
    result.player = buffer.nextU8();
    result.sum_up_to = buffer.nextI32();
    const range: any = { };
    { /* reading range (Range) */
      range.minimal = buffer.nextI8();
      range.maximal = buffer.nextI8();
    }
    result.range = range;
    const includes: any[] = [];
    // tslint:disable-next-line:one-variable-per-declaration
    for (let i = 0, n = buffer.nextU8(); i !== n; ++i) {
      const includes1: any = { };
      { /* reading includes1 (Selection) */
        includes1.code = buffer.nextU32();
        includes1.controller = buffer.nextU8();
        includes1.location = buffer.nextU8();
        includes1.sequence = buffer.nextU8();
        includes1.value = buffer.nextI32();
      }
      includes.push(includes1)
    }
    result.includes = includes;
    const optionals: any[] = [];
    // tslint:disable-next-line:one-variable-per-declaration
    for (let i = 0, n = buffer.nextU8(); i !== n; ++i) {
      const optionals1: any = { };
      { /* reading optionals1 (Selection) */
        optionals1.code = buffer.nextU32();
        optionals1.controller = buffer.nextU8();
        optionals1.location = buffer.nextU8();
        optionals1.sequence = buffer.nextU8();
        optionals1.value = buffer.nextI32();
      }
      optionals.push(optionals1)
    }
    result.optionals = optionals;
  }
  result.msgtype = 'MSG_SELECT_SUM';
  return result as MsgSelectSum;
}

/**
 * parse bytes as MsgSortCard (MSG_SORT_CARD)
 */
function parseMsgSortCard(buffer: BufferReader): MsgSortCard {
  const result: any = { };
  { /* reading result (MsgSortCard) */
    result.player = buffer.nextU8();
    const selection: any[] = [];
    // tslint:disable-next-line:one-variable-per-declaration
    for (let i = 0, n = buffer.nextU8(); i !== n; ++i) {
      const selection1: any = { };
      { /* reading selection1 (Selection) */
        selection1.code = buffer.nextU32();
        selection1.controller = buffer.nextU8();
        selection1.location = buffer.nextU8();
        selection1.sequence = buffer.nextU8();
      }
      selection.push(selection1)
    }
    result.selection = selection;
  }
  result.msgtype = 'MSG_SORT_CARD';
  return result as MsgSortCard;
}

/**
 * parse bytes as MsgSortChain (MSG_SORT_CHAIN)
 */
function parseMsgSortChain(buffer: BufferReader): MsgSortChain {
  const result: any = { };
  { /* reading result (MsgSortChain) */
    result.player = buffer.nextU8();
    const selection: any[] = [];
    // tslint:disable-next-line:one-variable-per-declaration
    for (let i = 0, n = buffer.nextU8(); i !== n; ++i) {
      const selection1: any = { };
      { /* reading selection1 (Selection) */
        selection1.code = buffer.nextU32();
        selection1.controller = buffer.nextU8();
        selection1.location = buffer.nextU8();
        selection1.sequence = buffer.nextU8();
      }
      selection.push(selection1)
    }
    result.selection = selection;
  }
  result.msgtype = 'MSG_SORT_CHAIN';
  return result as MsgSortChain;
}

/**
 * parse bytes as MsgConfirmDeckTop (MSG_CONFIRM_DECKTOP)
 */
function parseMsgConfirmDeckTop(buffer: BufferReader): MsgConfirmDeckTop {
  const result: any = { };
  { /* reading result (MsgConfirmDeckTop) */
    result.player = buffer.nextU8();
    const cards: any[] = [];
    // tslint:disable-next-line:one-variable-per-declaration
    for (let i = 0, n = buffer.nextU8(); i !== n; ++i) {
      const cards1: any = { };
      { /* reading cards1 (ConfirmCard) */
        cards1.code = buffer.nextU32();
        cards1.controller = buffer.nextU8();
        cards1.location = buffer.nextU8();
        cards1.sequence = buffer.nextU8();
      }
      cards.push(cards1)
    }
    result.cards = cards;
  }
  result.msgtype = 'MSG_CONFIRM_DECKTOP';
  return result as MsgConfirmDeckTop;
}

/**
 * parse bytes as MsgConfirmExtratop (MSG_CONFIRM_EXTRATOP)
 */
function parseMsgConfirmExtratop(buffer: BufferReader): MsgConfirmExtratop {
  const result: any = { };
  { /* reading result (MsgConfirmExtratop) */
    result.player = buffer.nextU8();
    const cards: any[] = [];
    // tslint:disable-next-line:one-variable-per-declaration
    for (let i = 0, n = buffer.nextU8(); i !== n; ++i) {
      const cards1: any = { };
      { /* reading cards1 (ConfirmCard) */
        cards1.code = buffer.nextU32();
        cards1.controller = buffer.nextU8();
        cards1.location = buffer.nextU8();
        cards1.sequence = buffer.nextU8();
      }
      cards.push(cards1)
    }
    result.cards = cards;
  }
  result.msgtype = 'MSG_CONFIRM_EXTRATOP';
  return result as MsgConfirmExtratop;
}

/**
 * parse bytes as MsgConfirmCards (MSG_CONFIRM_CARDS)
 */
function parseMsgConfirmCards(buffer: BufferReader): MsgConfirmCards {
  const result: any = { };
  { /* reading result (MsgConfirmCards) */
    result.player = buffer.nextU8();
    const cards: any[] = [];
    // tslint:disable-next-line:one-variable-per-declaration
    for (let i = 0, n = buffer.nextU8(); i !== n; ++i) {
      const cards1: any = { };
      { /* reading cards1 (ConfirmCard) */
        cards1.code = buffer.nextU32();
        cards1.controller = buffer.nextU8();
        cards1.location = buffer.nextU8();
        cards1.sequence = buffer.nextU8();
      }
      cards.push(cards1)
    }
    result.cards = cards;
  }
  result.msgtype = 'MSG_CONFIRM_CARDS';
  return result as MsgConfirmCards;
}

/**
 * parse bytes as MsgShuffleDeck (MSG_SHUFFLE_DECK)
 */
function parseMsgShuffleDeck(buffer: BufferReader): MsgShuffleDeck {
  const result: any = { };
  { /* reading result (MsgShuffleDeck) */
    result.player = buffer.nextU8();
  }
  result.msgtype = 'MSG_SHUFFLE_DECK';
  return result as MsgShuffleDeck;
}

/**
 * parse bytes as MsgRefreshDeck (MSG_REFRESH_DECK)
 */
function parseMsgRefreshDeck(buffer: BufferReader): MsgRefreshDeck {
  const result: any = { };
  { /* reading result (MsgRefreshDeck) */
    result.player = buffer.nextU8();
  }
  result.msgtype = 'MSG_REFRESH_DECK';
  return result as MsgRefreshDeck;
}

/**
 * parse bytes as MsgSwapGraveDeck (MSG_SWAP_GRAVE_DECK)
 */
function parseMsgSwapGraveDeck(buffer: BufferReader): MsgSwapGraveDeck {
  const result: any = { };
  { /* reading result (MsgSwapGraveDeck) */
    result.player = buffer.nextU8();
  }
  result.msgtype = 'MSG_SWAP_GRAVE_DECK';
  return result as MsgSwapGraveDeck;
}

/**
 * parse bytes as MsgNewTurn (MSG_NEW_TURN)
 */
function parseMsgNewTurn(buffer: BufferReader): MsgNewTurn {
  const result: any = { };
  { /* reading result (MsgNewTurn) */
    result.player = buffer.nextU8();
  }
  result.msgtype = 'MSG_NEW_TURN';
  return result as MsgNewTurn;
}

/**
 * parse bytes as MsgShuffleHand (MSG_SHUFFLE_HAND)
 */
function parseMsgShuffleHand(buffer: BufferReader): MsgShuffleHand {
  const result: any = { };
  { /* reading result (MsgShuffleHand) */
    result.player = buffer.nextU8();
    const cards: any[] = [];
    // tslint:disable-next-line:one-variable-per-declaration
    for (let i = 0, n = buffer.nextU8(); i !== n; ++i) {
      const cards1 = buffer.nextU32();
      cards.push(cards1)
    }
    result.cards = cards;
  }
  result.msgtype = 'MSG_SHUFFLE_HAND';
  return result as MsgShuffleHand;
}

/**
 * parse bytes as MsgShuffleExtra (MSG_SHUFFLE_EXTRA)
 */
function parseMsgShuffleExtra(buffer: