diff --git a/docs/static/openapi.yml b/docs/static/openapi.yml index c347031..c262924 100644 --- a/docs/static/openapi.yml +++ b/docs/static/openapi.yml @@ -103,6 +103,185 @@ paths: additionalProperties: {} tags: - Query + /b9lab/checkers/checkers/player_info: + get: + summary: Queries a list of PlayerInfo items. + operationId: B9LabCheckersCheckersPlayerInfoAll + responses: + '200': + description: A successful response. + schema: + type: object + properties: + playerInfo: + type: array + items: + type: object + properties: + index: + type: string + wonCount: + type: string + format: uint64 + lostCount: + type: string + format: uint64 + forfeitedCount: + type: string + format: uint64 + pagination: + type: object + properties: + next_key: + type: string + format: byte + title: |- + next_key is the key to be passed to PageRequest.key to + query the next page most efficiently + total: + type: string + format: uint64 + title: >- + total is total number of results available if + PageRequest.count_total + + was set, its value is undefined otherwise + description: >- + PageResponse is to be embedded in gRPC response messages where + the + + corresponding request message has used PageRequest. + + message SomeResponse { + repeated Bar results = 1; + PageResponse page = 2; + } + default: + description: An unexpected error response. + schema: + type: object + properties: + code: + type: integer + format: int32 + message: + type: string + details: + type: array + items: + type: object + properties: + '@type': + type: string + additionalProperties: {} + parameters: + - name: pagination.key + description: |- + key is a value returned in PageResponse.next_key to begin + querying the next page most efficiently. Only one of offset or key + should be set. + in: query + required: false + type: string + format: byte + - name: pagination.offset + description: >- + offset is a numeric offset that can be used when key is unavailable. + + It is less efficient than using key. Only one of offset or key + should + + be set. + in: query + required: false + type: string + format: uint64 + - name: pagination.limit + description: >- + limit is the total number of results to be returned in the result + page. + + If left empty it will default to a value to be set by each app. + in: query + required: false + type: string + format: uint64 + - name: pagination.count_total + description: >- + count_total is set to true to indicate that the result set should + include + + a count of the total number of items available for pagination in + UIs. + + count_total is only respected when offset is used. It is ignored + when key + + is set. + in: query + required: false + type: boolean + - name: pagination.reverse + description: >- + reverse is set to true if results are to be returned in the + descending order. + + + Since: cosmos-sdk 0.43 + in: query + required: false + type: boolean + tags: + - Query + '/b9lab/checkers/checkers/player_info/{index}': + get: + summary: Queries a PlayerInfo by index. + operationId: B9LabCheckersCheckersPlayerInfo + responses: + '200': + description: A successful response. + schema: + type: object + properties: + playerInfo: + type: object + properties: + index: + type: string + wonCount: + type: string + format: uint64 + lostCount: + type: string + format: uint64 + forfeitedCount: + type: string + format: uint64 + default: + description: An unexpected error response. + schema: + type: object + properties: + code: + type: integer + format: int32 + message: + type: string + details: + type: array + items: + type: object + properties: + '@type': + type: string + additionalProperties: {} + parameters: + - name: index + in: path + required: true + type: string + tags: + - Query /b9lab/checkers/checkers/stored_game: get: summary: Queries a list of StoredGame items. @@ -29824,6 +30003,64 @@ definitions: b9lab.checkers.checkers.Params: type: object description: Params defines the parameters for the module. + b9lab.checkers.checkers.PlayerInfo: + type: object + properties: + index: + type: string + wonCount: + type: string + format: uint64 + lostCount: + type: string + format: uint64 + forfeitedCount: + type: string + format: uint64 + b9lab.checkers.checkers.QueryAllPlayerInfoResponse: + type: object + properties: + playerInfo: + type: array + items: + type: object + properties: + index: + type: string + wonCount: + type: string + format: uint64 + lostCount: + type: string + format: uint64 + forfeitedCount: + type: string + format: uint64 + pagination: + type: object + properties: + next_key: + type: string + format: byte + title: |- + next_key is the key to be passed to PageRequest.key to + query the next page most efficiently + total: + type: string + format: uint64 + title: >- + total is total number of results available if + PageRequest.count_total + + was set, its value is undefined otherwise + description: |- + PageResponse is to be embedded in gRPC response messages where the + corresponding request message has used PageRequest. + + message SomeResponse { + repeated Bar results = 1; + PageResponse page = 2; + } b9lab.checkers.checkers.QueryAllStoredGameResponse: type: object properties: @@ -29890,6 +30127,23 @@ definitions: type: boolean reason: type: string + b9lab.checkers.checkers.QueryGetPlayerInfoResponse: + type: object + properties: + playerInfo: + type: object + properties: + index: + type: string + wonCount: + type: string + format: uint64 + lostCount: + type: string + format: uint64 + forfeitedCount: + type: string + format: uint64 b9lab.checkers.checkers.QueryGetStoredGameResponse: type: object properties: diff --git a/proto/checkers/genesis.proto b/proto/checkers/genesis.proto index 2a315f9..e4c3d3c 100644 --- a/proto/checkers/genesis.proto +++ b/proto/checkers/genesis.proto @@ -5,6 +5,7 @@ import "gogoproto/gogo.proto"; import "checkers/params.proto"; import "checkers/system_info.proto"; import "checkers/stored_game.proto"; +import "checkers/player_info.proto"; // this line is used by starport scaffolding # genesis/proto/import option go_package = "github.com/b9lab/checkers/x/checkers/types"; @@ -14,5 +15,6 @@ message GenesisState { Params params = 1 [(gogoproto.nullable) = false]; SystemInfo systemInfo = 2 [(gogoproto.nullable) = false]; repeated StoredGame storedGameList = 3 [(gogoproto.nullable) = false]; + repeated PlayerInfo playerInfoList = 4 [(gogoproto.nullable) = false]; // this line is used by starport scaffolding # genesis/proto/state } diff --git a/proto/checkers/player_info.proto b/proto/checkers/player_info.proto new file mode 100644 index 0000000..199367d --- /dev/null +++ b/proto/checkers/player_info.proto @@ -0,0 +1,12 @@ +syntax = "proto3"; +package b9lab.checkers.checkers; + +option go_package = "github.com/b9lab/checkers/x/checkers/types"; + +message PlayerInfo { + string index = 1; + uint64 wonCount = 2; + uint64 lostCount = 3; + uint64 forfeitedCount = 4; +} + diff --git a/proto/checkers/query.proto b/proto/checkers/query.proto index da4ee90..9940d7b 100644 --- a/proto/checkers/query.proto +++ b/proto/checkers/query.proto @@ -7,6 +7,7 @@ import "cosmos/base/query/v1beta1/pagination.proto"; import "checkers/params.proto"; import "checkers/system_info.proto"; import "checkers/stored_game.proto"; +import "checkers/player_info.proto"; // this line is used by starport scaffolding # 1 option go_package = "github.com/b9lab/checkers/x/checkers/types"; @@ -36,6 +37,16 @@ service Query { option (google.api.http).get = "/b9lab/checkers/checkers/can_play_move/{gameIndex}/{player}/{fromX}/{fromY}/{toX}/{toY}"; } +// Queries a PlayerInfo by index. + rpc PlayerInfo(QueryGetPlayerInfoRequest) returns (QueryGetPlayerInfoResponse) { + option (google.api.http).get = "/b9lab/checkers/checkers/player_info/{index}"; + } + + // Queries a list of PlayerInfo items. + rpc PlayerInfoAll(QueryAllPlayerInfoRequest) returns (QueryAllPlayerInfoResponse) { + option (google.api.http).get = "/b9lab/checkers/checkers/player_info"; + } + // this line is used by starport scaffolding # 2 } @@ -85,4 +96,22 @@ message QueryCanPlayMoveResponse { string reason = 2; } +message QueryGetPlayerInfoRequest { + string index = 1; + +} + +message QueryGetPlayerInfoResponse { + PlayerInfo playerInfo = 1 [(gogoproto.nullable) = false]; +} + +message QueryAllPlayerInfoRequest { + cosmos.base.query.v1beta1.PageRequest pagination = 1; +} + +message QueryAllPlayerInfoResponse { + repeated PlayerInfo playerInfo = 1 [(gogoproto.nullable) = false]; + cosmos.base.query.v1beta1.PageResponse pagination = 2; +} + // this line is used by starport scaffolding # 3 diff --git a/vue/src/store/generated/b9lab/checkers/b9lab.checkers.checkers/index.ts b/vue/src/store/generated/b9lab/checkers/b9lab.checkers.checkers/index.ts index 522cc55..3fb70ea 100755 --- a/vue/src/store/generated/b9lab/checkers/b9lab.checkers.checkers/index.ts +++ b/vue/src/store/generated/b9lab/checkers/b9lab.checkers.checkers/index.ts @@ -1,11 +1,12 @@ import { txClient, queryClient, MissingWalletError , registry} from './module' import { Params } from "./module/types/checkers/params" +import { PlayerInfo } from "./module/types/checkers/player_info" import { StoredGame } from "./module/types/checkers/stored_game" import { SystemInfo } from "./module/types/checkers/system_info" -export { Params, StoredGame, SystemInfo }; +export { Params, PlayerInfo, StoredGame, SystemInfo }; async function initTxClient(vuexGetters) { return await txClient(vuexGetters['common/wallet/signer'], { @@ -48,9 +49,12 @@ const getDefaultState = () => { StoredGame: {}, StoredGameAll: {}, CanPlayMove: {}, + PlayerInfo: {}, + PlayerInfoAll: {}, _Structure: { Params: getStructure(Params.fromPartial({})), + PlayerInfo: getStructure(PlayerInfo.fromPartial({})), StoredGame: getStructure(StoredGame.fromPartial({})), SystemInfo: getStructure(SystemInfo.fromPartial({})), @@ -111,6 +115,18 @@ export default { } return state.CanPlayMove[JSON.stringify(params)] ?? {} }, + getPlayerInfo: (state) => (params = { params: {}}) => { + if (!( params).query) { + ( params).query=null + } + return state.PlayerInfo[JSON.stringify(params)] ?? {} + }, + getPlayerInfoAll: (state) => (params = { params: {}}) => { + if (!( params).query) { + ( params).query=null + } + return state.PlayerInfoAll[JSON.stringify(params)] ?? {} + }, getTypeStructure: (state) => (type) => { return state._Structure[type].fields @@ -259,6 +275,54 @@ export default { }, + + + + + + async QueryPlayerInfo({ commit, rootGetters, getters }, { options: { subscribe, all} = { subscribe:false, all:false}, params, query=null }) { + try { + const key = params ?? {}; + const queryClient=await initQueryClient(rootGetters) + let value= (await queryClient.queryPlayerInfo( key.index)).data + + + commit('QUERY', { query: 'PlayerInfo', key: { params: {...key}, query}, value }) + if (subscribe) commit('SUBSCRIBE', { action: 'QueryPlayerInfo', payload: { options: { all }, params: {...key},query }}) + return getters['getPlayerInfo']( { params: {...key}, query}) ?? {} + } catch (e) { + throw new Error('QueryClient:QueryPlayerInfo API Node Unavailable. Could not perform query: ' + e.message) + + } + }, + + + + + + + + async QueryPlayerInfoAll({ commit, rootGetters, getters }, { options: { subscribe, all} = { subscribe:false, all:false}, params, query=null }) { + try { + const key = params ?? {}; + const queryClient=await initQueryClient(rootGetters) + let value= (await queryClient.queryPlayerInfoAll(query)).data + + + while (all && ( value).pagination && ( value).pagination.next_key!=null) { + let next_values=(await queryClient.queryPlayerInfoAll({...query, 'pagination.key':( value).pagination.next_key})).data + value = mergeResults(value, next_values); + } + commit('QUERY', { query: 'PlayerInfoAll', key: { params: {...key}, query}, value }) + if (subscribe) commit('SUBSCRIBE', { action: 'QueryPlayerInfoAll', payload: { options: { all }, params: {...key},query }}) + return getters['getPlayerInfoAll']( { params: {...key}, query}) ?? {} + } catch (e) { + throw new Error('QueryClient:QueryPlayerInfoAll API Node Unavailable. Could not perform query: ' + e.message) + + } + }, + + async sendMsgCreateGame({ rootGetters }, { value, fee = [], memo = '' }) { try { const txClient=await initTxClient(rootGetters) diff --git a/vue/src/store/generated/b9lab/checkers/b9lab.checkers.checkers/module/index.ts b/vue/src/store/generated/b9lab/checkers/b9lab.checkers.checkers/module/index.ts index af96a69..8803090 100755 --- a/vue/src/store/generated/b9lab/checkers/b9lab.checkers.checkers/module/index.ts +++ b/vue/src/store/generated/b9lab/checkers/b9lab.checkers.checkers/module/index.ts @@ -7,11 +7,9 @@ import { Api } from "./rest"; import { MsgCreateGame } from "./types/checkers/tx"; import { MsgPlayMove } from "./types/checkers/tx"; - const types = [ ["/b9lab.checkers.checkers.MsgCreateGame", MsgCreateGame], ["/b9lab.checkers.checkers.MsgPlayMove", MsgPlayMove], - ]; export const MissingWalletError = new Error("wallet is required"); diff --git a/vue/src/store/generated/b9lab/checkers/b9lab.checkers.checkers/module/rest.ts b/vue/src/store/generated/b9lab/checkers/b9lab.checkers.checkers/module/rest.ts index 8146614..33c2a2c 100644 --- a/vue/src/store/generated/b9lab/checkers/b9lab.checkers.checkers/module/rest.ts +++ b/vue/src/store/generated/b9lab/checkers/b9lab.checkers.checkers/module/rest.ts @@ -27,6 +27,34 @@ export interface CheckersMsgPlayMoveResponse { */ export type CheckersParams = object; +export interface CheckersPlayerInfo { + index?: string; + + /** @format uint64 */ + wonCount?: string; + + /** @format uint64 */ + lostCount?: string; + + /** @format uint64 */ + forfeitedCount?: string; +} + +export interface CheckersQueryAllPlayerInfoResponse { + playerInfo?: CheckersPlayerInfo[]; + + /** + * PageResponse is to be embedded in gRPC response messages where the + * corresponding request message has used PageRequest. + * + * message SomeResponse { + * repeated Bar results = 1; + * PageResponse page = 2; + * } + */ + pagination?: V1Beta1PageResponse; +} + export interface CheckersQueryAllStoredGameResponse { storedGame?: CheckersStoredGame[]; @@ -47,6 +75,10 @@ export interface CheckersQueryCanPlayMoveResponse { reason?: string; } +export interface CheckersQueryGetPlayerInfoResponse { + playerInfo?: CheckersPlayerInfo; +} + export interface CheckersQueryGetStoredGameResponse { storedGame?: CheckersStoredGame; } @@ -399,6 +431,48 @@ export class Api extends HttpClient + this.request({ + path: `/b9lab/checkers/checkers/player_info`, + method: "GET", + query: query, + format: "json", + ...params, + }); + + /** + * No description + * + * @tags Query + * @name QueryPlayerInfo + * @summary Queries a PlayerInfo by index. + * @request GET:/b9lab/checkers/checkers/player_info/{index} + */ + queryPlayerInfo = (index: string, params: RequestParams = {}) => + this.request({ + path: `/b9lab/checkers/checkers/player_info/${index}`, + method: "GET", + format: "json", + ...params, + }); + /** * No description * diff --git a/vue/src/store/generated/b9lab/checkers/b9lab.checkers.checkers/module/types/checkers/genesis.ts b/vue/src/store/generated/b9lab/checkers/b9lab.checkers.checkers/module/types/checkers/genesis.ts index b701470..b0e0475 100644 --- a/vue/src/store/generated/b9lab/checkers/b9lab.checkers.checkers/module/types/checkers/genesis.ts +++ b/vue/src/store/generated/b9lab/checkers/b9lab.checkers.checkers/module/types/checkers/genesis.ts @@ -2,6 +2,7 @@ import { Params } from "../checkers/params"; import { SystemInfo } from "../checkers/system_info"; import { StoredGame } from "../checkers/stored_game"; +import { PlayerInfo } from "../checkers/player_info"; import { Writer, Reader } from "protobufjs/minimal"; export const protobufPackage = "b9lab.checkers.checkers"; @@ -10,8 +11,9 @@ export const protobufPackage = "b9lab.checkers.checkers"; export interface GenesisState { params: Params | undefined; systemInfo: SystemInfo | undefined; - /** this line is used by starport scaffolding # genesis/proto/state */ storedGameList: StoredGame[]; + /** this line is used by starport scaffolding # genesis/proto/state */ + playerInfoList: PlayerInfo[]; } const baseGenesisState: object = {}; @@ -27,6 +29,9 @@ export const GenesisState = { for (const v of message.storedGameList) { StoredGame.encode(v!, writer.uint32(26).fork()).ldelim(); } + for (const v of message.playerInfoList) { + PlayerInfo.encode(v!, writer.uint32(34).fork()).ldelim(); + } return writer; }, @@ -35,6 +40,7 @@ export const GenesisState = { let end = length === undefined ? reader.len : reader.pos + length; const message = { ...baseGenesisState } as GenesisState; message.storedGameList = []; + message.playerInfoList = []; while (reader.pos < end) { const tag = reader.uint32(); switch (tag >>> 3) { @@ -49,6 +55,11 @@ export const GenesisState = { StoredGame.decode(reader, reader.uint32()) ); break; + case 4: + message.playerInfoList.push( + PlayerInfo.decode(reader, reader.uint32()) + ); + break; default: reader.skipType(tag & 7); break; @@ -60,6 +71,7 @@ export const GenesisState = { fromJSON(object: any): GenesisState { const message = { ...baseGenesisState } as GenesisState; message.storedGameList = []; + message.playerInfoList = []; if (object.params !== undefined && object.params !== null) { message.params = Params.fromJSON(object.params); } else { @@ -75,6 +87,11 @@ export const GenesisState = { message.storedGameList.push(StoredGame.fromJSON(e)); } } + if (object.playerInfoList !== undefined && object.playerInfoList !== null) { + for (const e of object.playerInfoList) { + message.playerInfoList.push(PlayerInfo.fromJSON(e)); + } + } return message; }, @@ -93,12 +110,20 @@ export const GenesisState = { } else { obj.storedGameList = []; } + if (message.playerInfoList) { + obj.playerInfoList = message.playerInfoList.map((e) => + e ? PlayerInfo.toJSON(e) : undefined + ); + } else { + obj.playerInfoList = []; + } return obj; }, fromPartial(object: DeepPartial): GenesisState { const message = { ...baseGenesisState } as GenesisState; message.storedGameList = []; + message.playerInfoList = []; if (object.params !== undefined && object.params !== null) { message.params = Params.fromPartial(object.params); } else { @@ -114,6 +139,11 @@ export const GenesisState = { message.storedGameList.push(StoredGame.fromPartial(e)); } } + if (object.playerInfoList !== undefined && object.playerInfoList !== null) { + for (const e of object.playerInfoList) { + message.playerInfoList.push(PlayerInfo.fromPartial(e)); + } + } return message; }, }; diff --git a/vue/src/store/generated/b9lab/checkers/b9lab.checkers.checkers/module/types/checkers/player_info.ts b/vue/src/store/generated/b9lab/checkers/b9lab.checkers.checkers/module/types/checkers/player_info.ts new file mode 100644 index 0000000..6774ec8 --- /dev/null +++ b/vue/src/store/generated/b9lab/checkers/b9lab.checkers.checkers/module/types/checkers/player_info.ts @@ -0,0 +1,157 @@ +/* eslint-disable */ +import * as Long from "long"; +import { util, configure, Writer, Reader } from "protobufjs/minimal"; + +export const protobufPackage = "b9lab.checkers.checkers"; + +export interface PlayerInfo { + index: string; + wonCount: number; + lostCount: number; + forfeitedCount: number; +} + +const basePlayerInfo: object = { + index: "", + wonCount: 0, + lostCount: 0, + forfeitedCount: 0, +}; + +export const PlayerInfo = { + encode(message: PlayerInfo, writer: Writer = Writer.create()): Writer { + if (message.index !== "") { + writer.uint32(10).string(message.index); + } + if (message.wonCount !== 0) { + writer.uint32(16).uint64(message.wonCount); + } + if (message.lostCount !== 0) { + writer.uint32(24).uint64(message.lostCount); + } + if (message.forfeitedCount !== 0) { + writer.uint32(32).uint64(message.forfeitedCount); + } + return writer; + }, + + decode(input: Reader | Uint8Array, length?: number): PlayerInfo { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...basePlayerInfo } as PlayerInfo; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.index = reader.string(); + break; + case 2: + message.wonCount = longToNumber(reader.uint64() as Long); + break; + case 3: + message.lostCount = longToNumber(reader.uint64() as Long); + break; + case 4: + message.forfeitedCount = longToNumber(reader.uint64() as Long); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): PlayerInfo { + const message = { ...basePlayerInfo } as PlayerInfo; + if (object.index !== undefined && object.index !== null) { + message.index = String(object.index); + } else { + message.index = ""; + } + if (object.wonCount !== undefined && object.wonCount !== null) { + message.wonCount = Number(object.wonCount); + } else { + message.wonCount = 0; + } + if (object.lostCount !== undefined && object.lostCount !== null) { + message.lostCount = Number(object.lostCount); + } else { + message.lostCount = 0; + } + if (object.forfeitedCount !== undefined && object.forfeitedCount !== null) { + message.forfeitedCount = Number(object.forfeitedCount); + } else { + message.forfeitedCount = 0; + } + return message; + }, + + toJSON(message: PlayerInfo): unknown { + const obj: any = {}; + message.index !== undefined && (obj.index = message.index); + message.wonCount !== undefined && (obj.wonCount = message.wonCount); + message.lostCount !== undefined && (obj.lostCount = message.lostCount); + message.forfeitedCount !== undefined && + (obj.forfeitedCount = message.forfeitedCount); + return obj; + }, + + fromPartial(object: DeepPartial): PlayerInfo { + const message = { ...basePlayerInfo } as PlayerInfo; + if (object.index !== undefined && object.index !== null) { + message.index = object.index; + } else { + message.index = ""; + } + if (object.wonCount !== undefined && object.wonCount !== null) { + message.wonCount = object.wonCount; + } else { + message.wonCount = 0; + } + if (object.lostCount !== undefined && object.lostCount !== null) { + message.lostCount = object.lostCount; + } else { + message.lostCount = 0; + } + if (object.forfeitedCount !== undefined && object.forfeitedCount !== null) { + message.forfeitedCount = object.forfeitedCount; + } else { + message.forfeitedCount = 0; + } + return message; + }, +}; + +declare var self: any | undefined; +declare var window: any | undefined; +var globalThis: any = (() => { + if (typeof globalThis !== "undefined") return globalThis; + if (typeof self !== "undefined") return self; + if (typeof window !== "undefined") return window; + if (typeof global !== "undefined") return global; + throw "Unable to locate global object"; +})(); + +type Builtin = Date | Function | Uint8Array | string | number | undefined; +export type DeepPartial = T extends Builtin + ? T + : T extends Array + ? Array> + : T extends ReadonlyArray + ? ReadonlyArray> + : T extends {} + ? { [K in keyof T]?: DeepPartial } + : Partial; + +function longToNumber(long: Long): number { + if (long.gt(Number.MAX_SAFE_INTEGER)) { + throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER"); + } + return long.toNumber(); +} + +if (util.Long !== Long) { + util.Long = Long as any; + configure(); +} diff --git a/vue/src/store/generated/b9lab/checkers/b9lab.checkers.checkers/module/types/checkers/query.ts b/vue/src/store/generated/b9lab/checkers/b9lab.checkers.checkers/module/types/checkers/query.ts index d3c6ea8..4e1f469 100644 --- a/vue/src/store/generated/b9lab/checkers/b9lab.checkers.checkers/module/types/checkers/query.ts +++ b/vue/src/store/generated/b9lab/checkers/b9lab.checkers.checkers/module/types/checkers/query.ts @@ -8,6 +8,7 @@ import { PageRequest, PageResponse, } from "../cosmos/base/query/v1beta1/pagination"; +import { PlayerInfo } from "../checkers/player_info"; export const protobufPackage = "b9lab.checkers.checkers"; @@ -57,6 +58,23 @@ export interface QueryCanPlayMoveResponse { reason: string; } +export interface QueryGetPlayerInfoRequest { + index: string; +} + +export interface QueryGetPlayerInfoResponse { + playerInfo: PlayerInfo | undefined; +} + +export interface QueryAllPlayerInfoRequest { + pagination: PageRequest | undefined; +} + +export interface QueryAllPlayerInfoResponse { + playerInfo: PlayerInfo[]; + pagination: PageResponse | undefined; +} + const baseQueryParamsRequest: object = {}; export const QueryParamsRequest = { @@ -836,6 +854,320 @@ export const QueryCanPlayMoveResponse = { }, }; +const baseQueryGetPlayerInfoRequest: object = { index: "" }; + +export const QueryGetPlayerInfoRequest = { + encode( + message: QueryGetPlayerInfoRequest, + writer: Writer = Writer.create() + ): Writer { + if (message.index !== "") { + writer.uint32(10).string(message.index); + } + return writer; + }, + + decode( + input: Reader | Uint8Array, + length?: number + ): QueryGetPlayerInfoRequest { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { + ...baseQueryGetPlayerInfoRequest, + } as QueryGetPlayerInfoRequest; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.index = reader.string(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): QueryGetPlayerInfoRequest { + const message = { + ...baseQueryGetPlayerInfoRequest, + } as QueryGetPlayerInfoRequest; + if (object.index !== undefined && object.index !== null) { + message.index = String(object.index); + } else { + message.index = ""; + } + return message; + }, + + toJSON(message: QueryGetPlayerInfoRequest): unknown { + const obj: any = {}; + message.index !== undefined && (obj.index = message.index); + return obj; + }, + + fromPartial( + object: DeepPartial + ): QueryGetPlayerInfoRequest { + const message = { + ...baseQueryGetPlayerInfoRequest, + } as QueryGetPlayerInfoRequest; + if (object.index !== undefined && object.index !== null) { + message.index = object.index; + } else { + message.index = ""; + } + return message; + }, +}; + +const baseQueryGetPlayerInfoResponse: object = {}; + +export const QueryGetPlayerInfoResponse = { + encode( + message: QueryGetPlayerInfoResponse, + writer: Writer = Writer.create() + ): Writer { + if (message.playerInfo !== undefined) { + PlayerInfo.encode(message.playerInfo, writer.uint32(10).fork()).ldelim(); + } + return writer; + }, + + decode( + input: Reader | Uint8Array, + length?: number + ): QueryGetPlayerInfoResponse { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { + ...baseQueryGetPlayerInfoResponse, + } as QueryGetPlayerInfoResponse; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.playerInfo = PlayerInfo.decode(reader, reader.uint32()); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): QueryGetPlayerInfoResponse { + const message = { + ...baseQueryGetPlayerInfoResponse, + } as QueryGetPlayerInfoResponse; + if (object.playerInfo !== undefined && object.playerInfo !== null) { + message.playerInfo = PlayerInfo.fromJSON(object.playerInfo); + } else { + message.playerInfo = undefined; + } + return message; + }, + + toJSON(message: QueryGetPlayerInfoResponse): unknown { + const obj: any = {}; + message.playerInfo !== undefined && + (obj.playerInfo = message.playerInfo + ? PlayerInfo.toJSON(message.playerInfo) + : undefined); + return obj; + }, + + fromPartial( + object: DeepPartial + ): QueryGetPlayerInfoResponse { + const message = { + ...baseQueryGetPlayerInfoResponse, + } as QueryGetPlayerInfoResponse; + if (object.playerInfo !== undefined && object.playerInfo !== null) { + message.playerInfo = PlayerInfo.fromPartial(object.playerInfo); + } else { + message.playerInfo = undefined; + } + return message; + }, +}; + +const baseQueryAllPlayerInfoRequest: object = {}; + +export const QueryAllPlayerInfoRequest = { + encode( + message: QueryAllPlayerInfoRequest, + writer: Writer = Writer.create() + ): Writer { + if (message.pagination !== undefined) { + PageRequest.encode(message.pagination, writer.uint32(10).fork()).ldelim(); + } + return writer; + }, + + decode( + input: Reader | Uint8Array, + length?: number + ): QueryAllPlayerInfoRequest { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { + ...baseQueryAllPlayerInfoRequest, + } as QueryAllPlayerInfoRequest; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.pagination = PageRequest.decode(reader, reader.uint32()); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): QueryAllPlayerInfoRequest { + const message = { + ...baseQueryAllPlayerInfoRequest, + } as QueryAllPlayerInfoRequest; + if (object.pagination !== undefined && object.pagination !== null) { + message.pagination = PageRequest.fromJSON(object.pagination); + } else { + message.pagination = undefined; + } + return message; + }, + + toJSON(message: QueryAllPlayerInfoRequest): unknown { + const obj: any = {}; + message.pagination !== undefined && + (obj.pagination = message.pagination + ? PageRequest.toJSON(message.pagination) + : undefined); + return obj; + }, + + fromPartial( + object: DeepPartial + ): QueryAllPlayerInfoRequest { + const message = { + ...baseQueryAllPlayerInfoRequest, + } as QueryAllPlayerInfoRequest; + if (object.pagination !== undefined && object.pagination !== null) { + message.pagination = PageRequest.fromPartial(object.pagination); + } else { + message.pagination = undefined; + } + return message; + }, +}; + +const baseQueryAllPlayerInfoResponse: object = {}; + +export const QueryAllPlayerInfoResponse = { + encode( + message: QueryAllPlayerInfoResponse, + writer: Writer = Writer.create() + ): Writer { + for (const v of message.playerInfo) { + PlayerInfo.encode(v!, writer.uint32(10).fork()).ldelim(); + } + if (message.pagination !== undefined) { + PageResponse.encode( + message.pagination, + writer.uint32(18).fork() + ).ldelim(); + } + return writer; + }, + + decode( + input: Reader | Uint8Array, + length?: number + ): QueryAllPlayerInfoResponse { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { + ...baseQueryAllPlayerInfoResponse, + } as QueryAllPlayerInfoResponse; + message.playerInfo = []; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.playerInfo.push(PlayerInfo.decode(reader, reader.uint32())); + break; + case 2: + message.pagination = PageResponse.decode(reader, reader.uint32()); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): QueryAllPlayerInfoResponse { + const message = { + ...baseQueryAllPlayerInfoResponse, + } as QueryAllPlayerInfoResponse; + message.playerInfo = []; + if (object.playerInfo !== undefined && object.playerInfo !== null) { + for (const e of object.playerInfo) { + message.playerInfo.push(PlayerInfo.fromJSON(e)); + } + } + if (object.pagination !== undefined && object.pagination !== null) { + message.pagination = PageResponse.fromJSON(object.pagination); + } else { + message.pagination = undefined; + } + return message; + }, + + toJSON(message: QueryAllPlayerInfoResponse): unknown { + const obj: any = {}; + if (message.playerInfo) { + obj.playerInfo = message.playerInfo.map((e) => + e ? PlayerInfo.toJSON(e) : undefined + ); + } else { + obj.playerInfo = []; + } + message.pagination !== undefined && + (obj.pagination = message.pagination + ? PageResponse.toJSON(message.pagination) + : undefined); + return obj; + }, + + fromPartial( + object: DeepPartial + ): QueryAllPlayerInfoResponse { + const message = { + ...baseQueryAllPlayerInfoResponse, + } as QueryAllPlayerInfoResponse; + message.playerInfo = []; + if (object.playerInfo !== undefined && object.playerInfo !== null) { + for (const e of object.playerInfo) { + message.playerInfo.push(PlayerInfo.fromPartial(e)); + } + } + if (object.pagination !== undefined && object.pagination !== null) { + message.pagination = PageResponse.fromPartial(object.pagination); + } else { + message.pagination = undefined; + } + return message; + }, +}; + /** Query defines the gRPC querier service. */ export interface Query { /** Parameters queries the parameters of the module. */ @@ -856,6 +1188,14 @@ export interface Query { CanPlayMove( request: QueryCanPlayMoveRequest ): Promise; + /** Queries a PlayerInfo by index. */ + PlayerInfo( + request: QueryGetPlayerInfoRequest + ): Promise; + /** Queries a list of PlayerInfo items. */ + PlayerInfoAll( + request: QueryAllPlayerInfoRequest + ): Promise; } export class QueryClientImpl implements Query { @@ -928,6 +1268,34 @@ export class QueryClientImpl implements Query { QueryCanPlayMoveResponse.decode(new Reader(data)) ); } + + PlayerInfo( + request: QueryGetPlayerInfoRequest + ): Promise { + const data = QueryGetPlayerInfoRequest.encode(request).finish(); + const promise = this.rpc.request( + "b9lab.checkers.checkers.Query", + "PlayerInfo", + data + ); + return promise.then((data) => + QueryGetPlayerInfoResponse.decode(new Reader(data)) + ); + } + + PlayerInfoAll( + request: QueryAllPlayerInfoRequest + ): Promise { + const data = QueryAllPlayerInfoRequest.encode(request).finish(); + const promise = this.rpc.request( + "b9lab.checkers.checkers.Query", + "PlayerInfoAll", + data + ); + return promise.then((data) => + QueryAllPlayerInfoResponse.decode(new Reader(data)) + ); + } } interface Rpc { diff --git a/x/checkers/client/cli/query.go b/x/checkers/client/cli/query.go index 6e80aee..fca0b2d 100644 --- a/x/checkers/client/cli/query.go +++ b/x/checkers/client/cli/query.go @@ -30,6 +30,8 @@ func GetQueryCmd(queryRoute string) *cobra.Command { cmd.AddCommand(CmdShowStoredGame()) cmd.AddCommand(CmdCanPlayMove()) + cmd.AddCommand(CmdListPlayerInfo()) + cmd.AddCommand(CmdShowPlayerInfo()) // this line is used by starport scaffolding # 1 return cmd diff --git a/x/checkers/client/cli/query_player_info.go b/x/checkers/client/cli/query_player_info.go new file mode 100644 index 0000000..d1607ca --- /dev/null +++ b/x/checkers/client/cli/query_player_info.go @@ -0,0 +1,73 @@ +package cli + +import ( + "context" + + "github.com/b9lab/checkers/x/checkers/types" + "github.com/cosmos/cosmos-sdk/client" + "github.com/cosmos/cosmos-sdk/client/flags" + "github.com/spf13/cobra" +) + +func CmdListPlayerInfo() *cobra.Command { + cmd := &cobra.Command{ + Use: "list-player-info", + Short: "list all playerInfo", + RunE: func(cmd *cobra.Command, args []string) error { + clientCtx := client.GetClientContextFromCmd(cmd) + + pageReq, err := client.ReadPageRequest(cmd.Flags()) + if err != nil { + return err + } + + queryClient := types.NewQueryClient(clientCtx) + + params := &types.QueryAllPlayerInfoRequest{ + Pagination: pageReq, + } + + res, err := queryClient.PlayerInfoAll(context.Background(), params) + if err != nil { + return err + } + + return clientCtx.PrintProto(res) + }, + } + + flags.AddPaginationFlagsToCmd(cmd, cmd.Use) + flags.AddQueryFlagsToCmd(cmd) + + return cmd +} + +func CmdShowPlayerInfo() *cobra.Command { + cmd := &cobra.Command{ + Use: "show-player-info [index]", + Short: "shows a playerInfo", + Args: cobra.ExactArgs(1), + RunE: func(cmd *cobra.Command, args []string) (err error) { + clientCtx := client.GetClientContextFromCmd(cmd) + + queryClient := types.NewQueryClient(clientCtx) + + argIndex := args[0] + + params := &types.QueryGetPlayerInfoRequest{ + Index: argIndex, + } + + res, err := queryClient.PlayerInfo(context.Background(), params) + if err != nil { + return err + } + + return clientCtx.PrintProto(res) + }, + } + + flags.AddQueryFlagsToCmd(cmd) + + return cmd +} diff --git a/x/checkers/client/cli/query_player_info_test.go b/x/checkers/client/cli/query_player_info_test.go new file mode 100644 index 0000000..df5162a --- /dev/null +++ b/x/checkers/client/cli/query_player_info_test.go @@ -0,0 +1,161 @@ +package cli_test + +import ( + "fmt" + "strconv" + "testing" + + "github.com/cosmos/cosmos-sdk/client/flags" + clitestutil "github.com/cosmos/cosmos-sdk/testutil/cli" + "github.com/stretchr/testify/require" + tmcli "github.com/tendermint/tendermint/libs/cli" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" + + "github.com/b9lab/checkers/testutil/network" + "github.com/b9lab/checkers/testutil/nullify" + "github.com/b9lab/checkers/x/checkers/client/cli" + "github.com/b9lab/checkers/x/checkers/types" +) + +// Prevent strconv unused error +var _ = strconv.IntSize + +func networkWithPlayerInfoObjects(t *testing.T, n int) (*network.Network, []types.PlayerInfo) { + t.Helper() + cfg := network.DefaultConfig() + state := types.GenesisState{} + require.NoError(t, cfg.Codec.UnmarshalJSON(cfg.GenesisState[types.ModuleName], &state)) + + for i := 0; i < n; i++ { + playerInfo := types.PlayerInfo{ + Index: strconv.Itoa(i), + } + nullify.Fill(&playerInfo) + state.PlayerInfoList = append(state.PlayerInfoList, playerInfo) + } + buf, err := cfg.Codec.MarshalJSON(&state) + require.NoError(t, err) + cfg.GenesisState[types.ModuleName] = buf + return network.New(t, cfg), state.PlayerInfoList +} + +func TestShowPlayerInfo(t *testing.T) { + net, objs := networkWithPlayerInfoObjects(t, 2) + + ctx := net.Validators[0].ClientCtx + common := []string{ + fmt.Sprintf("--%s=json", tmcli.OutputFlag), + } + for _, tc := range []struct { + desc string + idIndex string + + args []string + err error + obj types.PlayerInfo + }{ + { + desc: "found", + idIndex: objs[0].Index, + + args: common, + obj: objs[0], + }, + { + desc: "not found", + idIndex: strconv.Itoa(100000), + + args: common, + err: status.Error(codes.NotFound, "not found"), + }, + } { + t.Run(tc.desc, func(t *testing.T) { + args := []string{ + tc.idIndex, + } + args = append(args, tc.args...) + out, err := clitestutil.ExecTestCLICmd(ctx, cli.CmdShowPlayerInfo(), args) + if tc.err != nil { + stat, ok := status.FromError(tc.err) + require.True(t, ok) + require.ErrorIs(t, stat.Err(), tc.err) + } else { + require.NoError(t, err) + var resp types.QueryGetPlayerInfoResponse + require.NoError(t, net.Config.Codec.UnmarshalJSON(out.Bytes(), &resp)) + require.NotNil(t, resp.PlayerInfo) + require.Equal(t, + nullify.Fill(&tc.obj), + nullify.Fill(&resp.PlayerInfo), + ) + } + }) + } +} + +func TestListPlayerInfo(t *testing.T) { + net, objs := networkWithPlayerInfoObjects(t, 5) + + ctx := net.Validators[0].ClientCtx + request := func(next []byte, offset, limit uint64, total bool) []string { + args := []string{ + fmt.Sprintf("--%s=json", tmcli.OutputFlag), + } + if next == nil { + args = append(args, fmt.Sprintf("--%s=%d", flags.FlagOffset, offset)) + } else { + args = append(args, fmt.Sprintf("--%s=%s", flags.FlagPageKey, next)) + } + args = append(args, fmt.Sprintf("--%s=%d", flags.FlagLimit, limit)) + if total { + args = append(args, fmt.Sprintf("--%s", flags.FlagCountTotal)) + } + return args + } + t.Run("ByOffset", func(t *testing.T) { + step := 2 + for i := 0; i < len(objs); i += step { + args := request(nil, uint64(i), uint64(step), false) + out, err := clitestutil.ExecTestCLICmd(ctx, cli.CmdListPlayerInfo(), args) + require.NoError(t, err) + var resp types.QueryAllPlayerInfoResponse + require.NoError(t, net.Config.Codec.UnmarshalJSON(out.Bytes(), &resp)) + require.LessOrEqual(t, len(resp.PlayerInfo), step) + require.Subset(t, + nullify.Fill(objs), + nullify.Fill(resp.PlayerInfo), + ) + } + }) + t.Run("ByKey", func(t *testing.T) { + step := 2 + var next []byte + for i := 0; i < len(objs); i += step { + args := request(next, 0, uint64(step), false) + out, err := clitestutil.ExecTestCLICmd(ctx, cli.CmdListPlayerInfo(), args) + require.NoError(t, err) + var resp types.QueryAllPlayerInfoResponse + require.NoError(t, net.Config.Codec.UnmarshalJSON(out.Bytes(), &resp)) + require.LessOrEqual(t, len(resp.PlayerInfo), step) + require.Subset(t, + nullify.Fill(objs), + nullify.Fill(resp.PlayerInfo), + ) + next = resp.Pagination.NextKey + } + }) + t.Run("Total", func(t *testing.T) { + args := request(nil, 0, uint64(len(objs)), true) + out, err := clitestutil.ExecTestCLICmd(ctx, cli.CmdListPlayerInfo(), args) + require.NoError(t, err) + var resp types.QueryAllPlayerInfoResponse + require.NoError(t, net.Config.Codec.UnmarshalJSON(out.Bytes(), &resp)) + require.NoError(t, err) + require.Equal(t, len(objs), int(resp.Pagination.Total)) + require.ElementsMatch(t, + nullify.Fill(objs), + nullify.Fill(resp.PlayerInfo), + ) + }) +} diff --git a/x/checkers/genesis.go b/x/checkers/genesis.go index cea5489..1f8d9fd 100644 --- a/x/checkers/genesis.go +++ b/x/checkers/genesis.go @@ -15,6 +15,10 @@ func InitGenesis(ctx sdk.Context, k keeper.Keeper, genState types.GenesisState) for _, elem := range genState.StoredGameList { k.SetStoredGame(ctx, elem) } + // Set all the playerInfo + for _, elem := range genState.PlayerInfoList { + k.SetPlayerInfo(ctx, elem) + } // this line is used by starport scaffolding # genesis/module/init k.SetParams(ctx, genState.Params) } @@ -30,6 +34,7 @@ func ExportGenesis(ctx sdk.Context, k keeper.Keeper) *types.GenesisState { genesis.SystemInfo = systemInfo } genesis.StoredGameList = k.GetAllStoredGame(ctx) + genesis.PlayerInfoList = k.GetAllPlayerInfo(ctx) // this line is used by starport scaffolding # genesis/module/export return genesis diff --git a/x/checkers/genesis_test.go b/x/checkers/genesis_test.go index a523a72..ab2f44f 100644 --- a/x/checkers/genesis_test.go +++ b/x/checkers/genesis_test.go @@ -25,6 +25,14 @@ func TestGenesis(t *testing.T) { Index: "1", }, }, + PlayerInfoList: []types.PlayerInfo{ + { + Index: "0", + }, + { + Index: "1", + }, + }, // this line is used by starport scaffolding # genesis/test/state } @@ -38,5 +46,6 @@ func TestGenesis(t *testing.T) { require.Equal(t, genesisState.SystemInfo, got.SystemInfo) require.ElementsMatch(t, genesisState.StoredGameList, got.StoredGameList) + require.ElementsMatch(t, genesisState.PlayerInfoList, got.PlayerInfoList) // this line is used by starport scaffolding # genesis/test/assert } diff --git a/x/checkers/keeper/grpc_query_player_info.go b/x/checkers/keeper/grpc_query_player_info.go new file mode 100644 index 0000000..76bdd89 --- /dev/null +++ b/x/checkers/keeper/grpc_query_player_info.go @@ -0,0 +1,57 @@ +package keeper + +import ( + "context" + + "github.com/b9lab/checkers/x/checkers/types" + "github.com/cosmos/cosmos-sdk/store/prefix" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/types/query" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" +) + +func (k Keeper) PlayerInfoAll(c context.Context, req *types.QueryAllPlayerInfoRequest) (*types.QueryAllPlayerInfoResponse, error) { + if req == nil { + return nil, status.Error(codes.InvalidArgument, "invalid request") + } + + var playerInfos []types.PlayerInfo + ctx := sdk.UnwrapSDKContext(c) + + store := ctx.KVStore(k.storeKey) + playerInfoStore := prefix.NewStore(store, types.KeyPrefix(types.PlayerInfoKeyPrefix)) + + pageRes, err := query.Paginate(playerInfoStore, req.Pagination, func(key []byte, value []byte) error { + var playerInfo types.PlayerInfo + if err := k.cdc.Unmarshal(value, &playerInfo); err != nil { + return err + } + + playerInfos = append(playerInfos, playerInfo) + return nil + }) + + if err != nil { + return nil, status.Error(codes.Internal, err.Error()) + } + + return &types.QueryAllPlayerInfoResponse{PlayerInfo: playerInfos, Pagination: pageRes}, nil +} + +func (k Keeper) PlayerInfo(c context.Context, req *types.QueryGetPlayerInfoRequest) (*types.QueryGetPlayerInfoResponse, error) { + if req == nil { + return nil, status.Error(codes.InvalidArgument, "invalid request") + } + ctx := sdk.UnwrapSDKContext(c) + + val, found := k.GetPlayerInfo( + ctx, + req.Index, + ) + if !found { + return nil, status.Error(codes.NotFound, "not found") + } + + return &types.QueryGetPlayerInfoResponse{PlayerInfo: val}, nil +} diff --git a/x/checkers/keeper/grpc_query_player_info_test.go b/x/checkers/keeper/grpc_query_player_info_test.go new file mode 100644 index 0000000..9b699f3 --- /dev/null +++ b/x/checkers/keeper/grpc_query_player_info_test.go @@ -0,0 +1,126 @@ +package keeper_test + +import ( + "strconv" + "testing" + + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/types/query" + "github.com/stretchr/testify/require" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" + + keepertest "github.com/b9lab/checkers/testutil/keeper" + "github.com/b9lab/checkers/testutil/nullify" + "github.com/b9lab/checkers/x/checkers/types" +) + +// Prevent strconv unused error +var _ = strconv.IntSize + +func TestPlayerInfoQuerySingle(t *testing.T) { + keeper, ctx := keepertest.CheckersKeeper(t) + wctx := sdk.WrapSDKContext(ctx) + msgs := createNPlayerInfo(keeper, ctx, 2) + for _, tc := range []struct { + desc string + request *types.QueryGetPlayerInfoRequest + response *types.QueryGetPlayerInfoResponse + err error + }{ + { + desc: "First", + request: &types.QueryGetPlayerInfoRequest{ + Index: msgs[0].Index, + }, + response: &types.QueryGetPlayerInfoResponse{PlayerInfo: msgs[0]}, + }, + { + desc: "Second", + request: &types.QueryGetPlayerInfoRequest{ + Index: msgs[1].Index, + }, + response: &types.QueryGetPlayerInfoResponse{PlayerInfo: msgs[1]}, + }, + { + desc: "KeyNotFound", + request: &types.QueryGetPlayerInfoRequest{ + Index: strconv.Itoa(100000), + }, + err: status.Error(codes.NotFound, "not found"), + }, + { + desc: "InvalidRequest", + err: status.Error(codes.InvalidArgument, "invalid request"), + }, + } { + t.Run(tc.desc, func(t *testing.T) { + response, err := keeper.PlayerInfo(wctx, tc.request) + if tc.err != nil { + require.ErrorIs(t, err, tc.err) + } else { + require.NoError(t, err) + require.Equal(t, + nullify.Fill(tc.response), + nullify.Fill(response), + ) + } + }) + } +} + +func TestPlayerInfoQueryPaginated(t *testing.T) { + keeper, ctx := keepertest.CheckersKeeper(t) + wctx := sdk.WrapSDKContext(ctx) + msgs := createNPlayerInfo(keeper, ctx, 5) + + request := func(next []byte, offset, limit uint64, total bool) *types.QueryAllPlayerInfoRequest { + return &types.QueryAllPlayerInfoRequest{ + Pagination: &query.PageRequest{ + Key: next, + Offset: offset, + Limit: limit, + CountTotal: total, + }, + } + } + t.Run("ByOffset", func(t *testing.T) { + step := 2 + for i := 0; i < len(msgs); i += step { + resp, err := keeper.PlayerInfoAll(wctx, request(nil, uint64(i), uint64(step), false)) + require.NoError(t, err) + require.LessOrEqual(t, len(resp.PlayerInfo), step) + require.Subset(t, + nullify.Fill(msgs), + nullify.Fill(resp.PlayerInfo), + ) + } + }) + t.Run("ByKey", func(t *testing.T) { + step := 2 + var next []byte + for i := 0; i < len(msgs); i += step { + resp, err := keeper.PlayerInfoAll(wctx, request(next, 0, uint64(step), false)) + require.NoError(t, err) + require.LessOrEqual(t, len(resp.PlayerInfo), step) + require.Subset(t, + nullify.Fill(msgs), + nullify.Fill(resp.PlayerInfo), + ) + next = resp.Pagination.NextKey + } + }) + t.Run("Total", func(t *testing.T) { + resp, err := keeper.PlayerInfoAll(wctx, request(nil, 0, 0, true)) + require.NoError(t, err) + require.Equal(t, len(msgs), int(resp.Pagination.Total)) + require.ElementsMatch(t, + nullify.Fill(msgs), + nullify.Fill(resp.PlayerInfo), + ) + }) + t.Run("InvalidRequest", func(t *testing.T) { + _, err := keeper.PlayerInfoAll(wctx, nil) + require.ErrorIs(t, err, status.Error(codes.InvalidArgument, "invalid request")) + }) +} diff --git a/x/checkers/keeper/player_info.go b/x/checkers/keeper/player_info.go new file mode 100644 index 0000000..0b52bb9 --- /dev/null +++ b/x/checkers/keeper/player_info.go @@ -0,0 +1,63 @@ +package keeper + +import ( + "github.com/b9lab/checkers/x/checkers/types" + "github.com/cosmos/cosmos-sdk/store/prefix" + sdk "github.com/cosmos/cosmos-sdk/types" +) + +// SetPlayerInfo set a specific playerInfo in the store from its index +func (k Keeper) SetPlayerInfo(ctx sdk.Context, playerInfo types.PlayerInfo) { + store := prefix.NewStore(ctx.KVStore(k.storeKey), types.KeyPrefix(types.PlayerInfoKeyPrefix)) + b := k.cdc.MustMarshal(&playerInfo) + store.Set(types.PlayerInfoKey( + playerInfo.Index, + ), b) +} + +// GetPlayerInfo returns a playerInfo from its index +func (k Keeper) GetPlayerInfo( + ctx sdk.Context, + index string, + +) (val types.PlayerInfo, found bool) { + store := prefix.NewStore(ctx.KVStore(k.storeKey), types.KeyPrefix(types.PlayerInfoKeyPrefix)) + + b := store.Get(types.PlayerInfoKey( + index, + )) + if b == nil { + return val, false + } + + k.cdc.MustUnmarshal(b, &val) + return val, true +} + +// RemovePlayerInfo removes a playerInfo from the store +func (k Keeper) RemovePlayerInfo( + ctx sdk.Context, + index string, + +) { + store := prefix.NewStore(ctx.KVStore(k.storeKey), types.KeyPrefix(types.PlayerInfoKeyPrefix)) + store.Delete(types.PlayerInfoKey( + index, + )) +} + +// GetAllPlayerInfo returns all playerInfo +func (k Keeper) GetAllPlayerInfo(ctx sdk.Context) (list []types.PlayerInfo) { + store := prefix.NewStore(ctx.KVStore(k.storeKey), types.KeyPrefix(types.PlayerInfoKeyPrefix)) + iterator := sdk.KVStorePrefixIterator(store, []byte{}) + + defer iterator.Close() + + for ; iterator.Valid(); iterator.Next() { + var val types.PlayerInfo + k.cdc.MustUnmarshal(iterator.Value(), &val) + list = append(list, val) + } + + return +} diff --git a/x/checkers/keeper/player_info_test.go b/x/checkers/keeper/player_info_test.go new file mode 100644 index 0000000..a75ca03 --- /dev/null +++ b/x/checkers/keeper/player_info_test.go @@ -0,0 +1,63 @@ +package keeper_test + +import ( + "strconv" + "testing" + + keepertest "github.com/b9lab/checkers/testutil/keeper" + "github.com/b9lab/checkers/testutil/nullify" + "github.com/b9lab/checkers/x/checkers/keeper" + "github.com/b9lab/checkers/x/checkers/types" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/stretchr/testify/require" +) + +// Prevent strconv unused error +var _ = strconv.IntSize + +func createNPlayerInfo(keeper *keeper.Keeper, ctx sdk.Context, n int) []types.PlayerInfo { + items := make([]types.PlayerInfo, n) + for i := range items { + items[i].Index = strconv.Itoa(i) + + keeper.SetPlayerInfo(ctx, items[i]) + } + return items +} + +func TestPlayerInfoGet(t *testing.T) { + keeper, ctx := keepertest.CheckersKeeper(t) + items := createNPlayerInfo(keeper, ctx, 10) + for _, item := range items { + rst, found := keeper.GetPlayerInfo(ctx, + item.Index, + ) + require.True(t, found) + require.Equal(t, + nullify.Fill(&item), + nullify.Fill(&rst), + ) + } +} +func TestPlayerInfoRemove(t *testing.T) { + keeper, ctx := keepertest.CheckersKeeper(t) + items := createNPlayerInfo(keeper, ctx, 10) + for _, item := range items { + keeper.RemovePlayerInfo(ctx, + item.Index, + ) + _, found := keeper.GetPlayerInfo(ctx, + item.Index, + ) + require.False(t, found) + } +} + +func TestPlayerInfoGetAll(t *testing.T) { + keeper, ctx := keepertest.CheckersKeeper(t) + items := createNPlayerInfo(keeper, ctx, 10) + require.ElementsMatch(t, + nullify.Fill(items), + nullify.Fill(keeper.GetAllPlayerInfo(ctx)), + ) +} diff --git a/x/checkers/types/genesis.go b/x/checkers/types/genesis.go index af94fac..f82798d 100644 --- a/x/checkers/types/genesis.go +++ b/x/checkers/types/genesis.go @@ -16,6 +16,7 @@ func DefaultGenesis() *GenesisState { FifoTailIndex: NoFifoIndex, }, StoredGameList: []StoredGame{}, + PlayerInfoList: []PlayerInfo{}, // this line is used by starport scaffolding # genesis/types/default Params: DefaultParams(), } @@ -34,6 +35,16 @@ func (gs GenesisState) Validate() error { } storedGameIndexMap[index] = struct{}{} } + // Check for duplicated index in playerInfo + playerInfoIndexMap := make(map[string]struct{}) + + for _, elem := range gs.PlayerInfoList { + index := string(PlayerInfoKey(elem.Index)) + if _, ok := playerInfoIndexMap[index]; ok { + return fmt.Errorf("duplicated index for playerInfo") + } + playerInfoIndexMap[index] = struct{}{} + } // this line is used by starport scaffolding # genesis/types/validate return gs.Params.Validate() diff --git a/x/checkers/types/genesis.pb.go b/x/checkers/types/genesis.pb.go index ef09af0..e71b138 100644 --- a/x/checkers/types/genesis.pb.go +++ b/x/checkers/types/genesis.pb.go @@ -28,6 +28,7 @@ type GenesisState struct { Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"` SystemInfo SystemInfo `protobuf:"bytes,2,opt,name=systemInfo,proto3" json:"systemInfo"` StoredGameList []StoredGame `protobuf:"bytes,3,rep,name=storedGameList,proto3" json:"storedGameList"` + PlayerInfoList []PlayerInfo `protobuf:"bytes,4,rep,name=playerInfoList,proto3" json:"playerInfoList"` } func (m *GenesisState) Reset() { *m = GenesisState{} } @@ -84,6 +85,13 @@ func (m *GenesisState) GetStoredGameList() []StoredGame { return nil } +func (m *GenesisState) GetPlayerInfoList() []PlayerInfo { + if m != nil { + return m.PlayerInfoList + } + return nil +} + func init() { proto.RegisterType((*GenesisState)(nil), "b9lab.checkers.checkers.GenesisState") } @@ -91,24 +99,26 @@ func init() { func init() { proto.RegisterFile("checkers/genesis.proto", fileDescriptor_6e928243c164a8dc) } var fileDescriptor_6e928243c164a8dc = []byte{ - // 268 bytes of a gzipped FileDescriptorProto + // 296 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0x4b, 0xce, 0x48, 0x4d, 0xce, 0x4e, 0x2d, 0x2a, 0xd6, 0x4f, 0x4f, 0xcd, 0x4b, 0x2d, 0xce, 0x2c, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, 0x4f, 0xb2, 0xcc, 0x49, 0x4c, 0xd2, 0x83, 0xc9, 0xc2, 0x19, 0x52, 0x22, 0xe9, 0xf9, 0xe9, 0xf9, 0x60, 0x35, 0xfa, 0x20, 0x16, 0x44, 0xb9, 0x94, 0x28, 0xdc, 0x98, 0x82, 0xc4, 0xa2, 0xc4, 0x5c, 0xa8, 0x29, 0x52, 0x52, 0x70, 0xe1, 0xe2, 0xca, 0xe2, 0x92, 0xd4, 0xdc, 0xf8, 0xcc, 0xbc, 0xb4, 0x7c, 0x4c, 0xb9, 0x92, 0xfc, 0xa2, 0xd4, 0x94, 0xf8, 0xf4, 0xc4, 0xdc, - 0x54, 0x88, 0x9c, 0xd2, 0x6b, 0x46, 0x2e, 0x1e, 0x77, 0x88, 0x7b, 0x82, 0x4b, 0x12, 0x4b, 0x52, - 0x85, 0x6c, 0xb9, 0xd8, 0x20, 0x06, 0x4b, 0x30, 0x2a, 0x30, 0x6a, 0x70, 0x1b, 0xc9, 0xeb, 0xe1, - 0x70, 0x9f, 0x5e, 0x00, 0x58, 0x99, 0x13, 0xcb, 0x89, 0x7b, 0xf2, 0x0c, 0x41, 0x50, 0x4d, 0x42, - 0x9e, 0x5c, 0x5c, 0x10, 0x07, 0x78, 0xe6, 0xa5, 0xe5, 0x4b, 0x30, 0x81, 0x8d, 0x50, 0xc6, 0x69, - 0x44, 0x30, 0x5c, 0x29, 0xd4, 0x18, 0x24, 0xcd, 0x42, 0x81, 0x5c, 0x7c, 0x10, 0xf7, 0xba, 0x27, - 0xe6, 0xa6, 0xfa, 0x64, 0x16, 0x97, 0x48, 0x30, 0x2b, 0x30, 0xe3, 0x37, 0x0e, 0xae, 0x1c, 0x6a, - 0x1c, 0x9a, 0x01, 0x4e, 0x2e, 0x27, 0x1e, 0xc9, 0x31, 0x5e, 0x78, 0x24, 0xc7, 0xf8, 0xe0, 0x91, - 0x1c, 0xe3, 0x84, 0xc7, 0x72, 0x0c, 0x17, 0x1e, 0xcb, 0x31, 0xdc, 0x78, 0x2c, 0xc7, 0x10, 0xa5, - 0x95, 0x9e, 0x59, 0x92, 0x51, 0x9a, 0xa4, 0x97, 0x9c, 0x9f, 0xab, 0x0f, 0x36, 0x5e, 0x1f, 0x1e, - 0x68, 0x15, 0x08, 0x66, 0x49, 0x65, 0x41, 0x6a, 0x71, 0x12, 0x1b, 0x38, 0xe8, 0x8c, 0x01, 0x01, - 0x00, 0x00, 0xff, 0xff, 0x31, 0x59, 0xee, 0x2b, 0xd2, 0x01, 0x00, 0x00, + 0x54, 0x0c, 0xb9, 0x82, 0x9c, 0xc4, 0xca, 0xd4, 0x22, 0x24, 0x7d, 0x4a, 0xfb, 0x98, 0xb8, 0x78, + 0xdc, 0x21, 0x6e, 0x0d, 0x2e, 0x49, 0x2c, 0x49, 0x15, 0xb2, 0xe5, 0x62, 0x83, 0x58, 0x2a, 0xc1, + 0xa8, 0xc0, 0xa8, 0xc1, 0x6d, 0x24, 0xaf, 0x87, 0xc3, 0xed, 0x7a, 0x01, 0x60, 0x65, 0x4e, 0x2c, + 0x27, 0xee, 0xc9, 0x33, 0x04, 0x41, 0x35, 0x09, 0x79, 0x72, 0x71, 0x41, 0x1c, 0xe7, 0x99, 0x97, + 0x96, 0x2f, 0xc1, 0x04, 0x36, 0x42, 0x19, 0xa7, 0x11, 0xc1, 0x70, 0xa5, 0x50, 0x63, 0x90, 0x34, + 0x0b, 0x05, 0x72, 0xf1, 0x41, 0xfc, 0xe2, 0x9e, 0x98, 0x9b, 0xea, 0x93, 0x59, 0x5c, 0x22, 0xc1, + 0xac, 0xc0, 0x8c, 0xdf, 0x38, 0xb8, 0x72, 0xa8, 0x71, 0x68, 0x06, 0x80, 0x8c, 0x84, 0x04, 0x01, + 0xc8, 0x02, 0xb0, 0x91, 0x2c, 0x04, 0x8c, 0x0c, 0x80, 0x2b, 0x87, 0x19, 0x89, 0x6a, 0x80, 0x93, + 0xcb, 0x89, 0x47, 0x72, 0x8c, 0x17, 0x1e, 0xc9, 0x31, 0x3e, 0x78, 0x24, 0xc7, 0x38, 0xe1, 0xb1, + 0x1c, 0xc3, 0x85, 0xc7, 0x72, 0x0c, 0x37, 0x1e, 0xcb, 0x31, 0x44, 0x69, 0xa5, 0x67, 0x96, 0x64, + 0x94, 0x26, 0xe9, 0x25, 0xe7, 0xe7, 0xea, 0x83, 0x8d, 0xd7, 0x87, 0xc7, 0x43, 0x05, 0x82, 0x59, + 0x52, 0x59, 0x90, 0x5a, 0x9c, 0xc4, 0x06, 0x8e, 0x0d, 0x63, 0x40, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x45, 0x91, 0xbf, 0xc2, 0x41, 0x02, 0x00, 0x00, } func (m *GenesisState) Marshal() (dAtA []byte, err error) { @@ -131,6 +141,20 @@ func (m *GenesisState) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if len(m.PlayerInfoList) > 0 { + for iNdEx := len(m.PlayerInfoList) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.PlayerInfoList[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenesis(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + } if len(m.StoredGameList) > 0 { for iNdEx := len(m.StoredGameList) - 1; iNdEx >= 0; iNdEx-- { { @@ -195,6 +219,12 @@ func (m *GenesisState) Size() (n int) { n += 1 + l + sovGenesis(uint64(l)) } } + if len(m.PlayerInfoList) > 0 { + for _, e := range m.PlayerInfoList { + l = e.Size() + n += 1 + l + sovGenesis(uint64(l)) + } + } return n } @@ -333,6 +363,40 @@ func (m *GenesisState) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PlayerInfoList", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PlayerInfoList = append(m.PlayerInfoList, PlayerInfo{}) + if err := m.PlayerInfoList[len(m.PlayerInfoList)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipGenesis(dAtA[iNdEx:]) diff --git a/x/checkers/types/genesis_test.go b/x/checkers/types/genesis_test.go index 6d6abe4..3bd755f 100644 --- a/x/checkers/types/genesis_test.go +++ b/x/checkers/types/genesis_test.go @@ -33,6 +33,14 @@ func TestGenesisState_Validate(t *testing.T) { Index: "1", }, }, + PlayerInfoList: []types.PlayerInfo{ + { + Index: "0", + }, + { + Index: "1", + }, + }, // this line is used by starport scaffolding # types/genesis/validField }, valid: true, @@ -51,6 +59,20 @@ func TestGenesisState_Validate(t *testing.T) { }, valid: false, }, + { + desc: "duplicated playerInfo", + genState: &types.GenesisState{ + PlayerInfoList: []types.PlayerInfo{ + { + Index: "0", + }, + { + Index: "0", + }, + }, + }, + valid: false, + }, // this line is used by starport scaffolding # types/genesis/testcase } { t.Run(tc.desc, func(t *testing.T) { @@ -73,6 +95,7 @@ func TestDefaultGenesisState_ExpectedInitialNextId(t *testing.T) { FifoHeadIndex: "-1", FifoTailIndex: "-1", }, + PlayerInfoList: []types.PlayerInfo{}, }, types.DefaultGenesis()) } diff --git a/x/checkers/types/key_player_info.go b/x/checkers/types/key_player_info.go new file mode 100644 index 0000000..e6ae7d2 --- /dev/null +++ b/x/checkers/types/key_player_info.go @@ -0,0 +1,23 @@ +package types + +import "encoding/binary" + +var _ binary.ByteOrder + +const ( + // PlayerInfoKeyPrefix is the prefix to retrieve all PlayerInfo + PlayerInfoKeyPrefix = "PlayerInfo/value/" +) + +// PlayerInfoKey returns the store key to retrieve a PlayerInfo from the index fields +func PlayerInfoKey( + index string, +) []byte { + var key []byte + + indexBytes := []byte(index) + key = append(key, indexBytes...) + key = append(key, []byte("/")...) + + return key +} diff --git a/x/checkers/types/player_info.pb.go b/x/checkers/types/player_info.pb.go new file mode 100644 index 0000000..fef3f29 --- /dev/null +++ b/x/checkers/types/player_info.pb.go @@ -0,0 +1,422 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: checkers/player_info.proto + +package types + +import ( + fmt "fmt" + proto "github.com/gogo/protobuf/proto" + io "io" + math "math" + math_bits "math/bits" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +type PlayerInfo struct { + Index string `protobuf:"bytes,1,opt,name=index,proto3" json:"index,omitempty"` + WonCount uint64 `protobuf:"varint,2,opt,name=wonCount,proto3" json:"wonCount,omitempty"` + LostCount uint64 `protobuf:"varint,3,opt,name=lostCount,proto3" json:"lostCount,omitempty"` + ForfeitedCount uint64 `protobuf:"varint,4,opt,name=forfeitedCount,proto3" json:"forfeitedCount,omitempty"` +} + +func (m *PlayerInfo) Reset() { *m = PlayerInfo{} } +func (m *PlayerInfo) String() string { return proto.CompactTextString(m) } +func (*PlayerInfo) ProtoMessage() {} +func (*PlayerInfo) Descriptor() ([]byte, []int) { + return fileDescriptor_11be7192ff7df15e, []int{0} +} +func (m *PlayerInfo) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *PlayerInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_PlayerInfo.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *PlayerInfo) XXX_Merge(src proto.Message) { + xxx_messageInfo_PlayerInfo.Merge(m, src) +} +func (m *PlayerInfo) XXX_Size() int { + return m.Size() +} +func (m *PlayerInfo) XXX_DiscardUnknown() { + xxx_messageInfo_PlayerInfo.DiscardUnknown(m) +} + +var xxx_messageInfo_PlayerInfo proto.InternalMessageInfo + +func (m *PlayerInfo) GetIndex() string { + if m != nil { + return m.Index + } + return "" +} + +func (m *PlayerInfo) GetWonCount() uint64 { + if m != nil { + return m.WonCount + } + return 0 +} + +func (m *PlayerInfo) GetLostCount() uint64 { + if m != nil { + return m.LostCount + } + return 0 +} + +func (m *PlayerInfo) GetForfeitedCount() uint64 { + if m != nil { + return m.ForfeitedCount + } + return 0 +} + +func init() { + proto.RegisterType((*PlayerInfo)(nil), "b9lab.checkers.checkers.PlayerInfo") +} + +func init() { proto.RegisterFile("checkers/player_info.proto", fileDescriptor_11be7192ff7df15e) } + +var fileDescriptor_11be7192ff7df15e = []byte{ + // 208 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4a, 0xce, 0x48, 0x4d, + 0xce, 0x4e, 0x2d, 0x2a, 0xd6, 0x2f, 0xc8, 0x49, 0xac, 0x4c, 0x2d, 0x8a, 0xcf, 0xcc, 0x4b, 0xcb, + 0xd7, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, 0x4f, 0xb2, 0xcc, 0x49, 0x4c, 0xd2, 0x83, 0xa9, + 0x80, 0x33, 0x94, 0x5a, 0x18, 0xb9, 0xb8, 0x02, 0xc0, 0xca, 0x3d, 0xf3, 0xd2, 0xf2, 0x85, 0x44, + 0xb8, 0x58, 0x33, 0xf3, 0x52, 0x52, 0x2b, 0x24, 0x18, 0x15, 0x18, 0x35, 0x38, 0x83, 0x20, 0x1c, + 0x21, 0x29, 0x2e, 0x8e, 0xf2, 0xfc, 0x3c, 0xe7, 0xfc, 0xd2, 0xbc, 0x12, 0x09, 0x26, 0x05, 0x46, + 0x0d, 0x96, 0x20, 0x38, 0x5f, 0x48, 0x86, 0x8b, 0x33, 0x27, 0xbf, 0xb8, 0x04, 0x22, 0xc9, 0x0c, + 0x96, 0x44, 0x08, 0x08, 0xa9, 0x71, 0xf1, 0xa5, 0xe5, 0x17, 0xa5, 0xa5, 0x66, 0x96, 0xa4, 0xa6, + 0x40, 0x94, 0xb0, 0x80, 0x95, 0xa0, 0x89, 0x3a, 0xb9, 0x9c, 0x78, 0x24, 0xc7, 0x78, 0xe1, 0x91, + 0x1c, 0xe3, 0x83, 0x47, 0x72, 0x8c, 0x13, 0x1e, 0xcb, 0x31, 0x5c, 0x78, 0x2c, 0xc7, 0x70, 0xe3, + 0xb1, 0x1c, 0x43, 0x94, 0x56, 0x7a, 0x66, 0x49, 0x46, 0x69, 0x92, 0x5e, 0x72, 0x7e, 0xae, 0x3e, + 0xd8, 0x13, 0xfa, 0x70, 0x6f, 0x56, 0x20, 0x98, 0x25, 0x95, 0x05, 0xa9, 0xc5, 0x49, 0x6c, 0x60, + 0xcf, 0x1a, 0x03, 0x02, 0x00, 0x00, 0xff, 0xff, 0x62, 0xe3, 0x47, 0xe5, 0x0a, 0x01, 0x00, 0x00, +} + +func (m *PlayerInfo) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *PlayerInfo) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *PlayerInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.ForfeitedCount != 0 { + i = encodeVarintPlayerInfo(dAtA, i, uint64(m.ForfeitedCount)) + i-- + dAtA[i] = 0x20 + } + if m.LostCount != 0 { + i = encodeVarintPlayerInfo(dAtA, i, uint64(m.LostCount)) + i-- + dAtA[i] = 0x18 + } + if m.WonCount != 0 { + i = encodeVarintPlayerInfo(dAtA, i, uint64(m.WonCount)) + i-- + dAtA[i] = 0x10 + } + if len(m.Index) > 0 { + i -= len(m.Index) + copy(dAtA[i:], m.Index) + i = encodeVarintPlayerInfo(dAtA, i, uint64(len(m.Index))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintPlayerInfo(dAtA []byte, offset int, v uint64) int { + offset -= sovPlayerInfo(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *PlayerInfo) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Index) + if l > 0 { + n += 1 + l + sovPlayerInfo(uint64(l)) + } + if m.WonCount != 0 { + n += 1 + sovPlayerInfo(uint64(m.WonCount)) + } + if m.LostCount != 0 { + n += 1 + sovPlayerInfo(uint64(m.LostCount)) + } + if m.ForfeitedCount != 0 { + n += 1 + sovPlayerInfo(uint64(m.ForfeitedCount)) + } + return n +} + +func sovPlayerInfo(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozPlayerInfo(x uint64) (n int) { + return sovPlayerInfo(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *PlayerInfo) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPlayerInfo + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: PlayerInfo: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PlayerInfo: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPlayerInfo + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthPlayerInfo + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthPlayerInfo + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Index = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field WonCount", wireType) + } + m.WonCount = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPlayerInfo + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.WonCount |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field LostCount", wireType) + } + m.LostCount = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPlayerInfo + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.LostCount |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ForfeitedCount", wireType) + } + m.ForfeitedCount = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPlayerInfo + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ForfeitedCount |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipPlayerInfo(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthPlayerInfo + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipPlayerInfo(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowPlayerInfo + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowPlayerInfo + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowPlayerInfo + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthPlayerInfo + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupPlayerInfo + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthPlayerInfo + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthPlayerInfo = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowPlayerInfo = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupPlayerInfo = fmt.Errorf("proto: unexpected end of group") +) diff --git a/x/checkers/types/query.pb.go b/x/checkers/types/query.pb.go index 67afd86..8ea84bf 100644 --- a/x/checkers/types/query.pb.go +++ b/x/checkers/types/query.pb.go @@ -513,6 +513,190 @@ func (m *QueryCanPlayMoveResponse) GetReason() string { return "" } +type QueryGetPlayerInfoRequest struct { + Index string `protobuf:"bytes,1,opt,name=index,proto3" json:"index,omitempty"` +} + +func (m *QueryGetPlayerInfoRequest) Reset() { *m = QueryGetPlayerInfoRequest{} } +func (m *QueryGetPlayerInfoRequest) String() string { return proto.CompactTextString(m) } +func (*QueryGetPlayerInfoRequest) ProtoMessage() {} +func (*QueryGetPlayerInfoRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_3c482788bba85e7a, []int{10} +} +func (m *QueryGetPlayerInfoRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryGetPlayerInfoRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryGetPlayerInfoRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *QueryGetPlayerInfoRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryGetPlayerInfoRequest.Merge(m, src) +} +func (m *QueryGetPlayerInfoRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryGetPlayerInfoRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryGetPlayerInfoRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryGetPlayerInfoRequest proto.InternalMessageInfo + +func (m *QueryGetPlayerInfoRequest) GetIndex() string { + if m != nil { + return m.Index + } + return "" +} + +type QueryGetPlayerInfoResponse struct { + PlayerInfo PlayerInfo `protobuf:"bytes,1,opt,name=playerInfo,proto3" json:"playerInfo"` +} + +func (m *QueryGetPlayerInfoResponse) Reset() { *m = QueryGetPlayerInfoResponse{} } +func (m *QueryGetPlayerInfoResponse) String() string { return proto.CompactTextString(m) } +func (*QueryGetPlayerInfoResponse) ProtoMessage() {} +func (*QueryGetPlayerInfoResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_3c482788bba85e7a, []int{11} +} +func (m *QueryGetPlayerInfoResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryGetPlayerInfoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryGetPlayerInfoResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *QueryGetPlayerInfoResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryGetPlayerInfoResponse.Merge(m, src) +} +func (m *QueryGetPlayerInfoResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryGetPlayerInfoResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryGetPlayerInfoResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryGetPlayerInfoResponse proto.InternalMessageInfo + +func (m *QueryGetPlayerInfoResponse) GetPlayerInfo() PlayerInfo { + if m != nil { + return m.PlayerInfo + } + return PlayerInfo{} +} + +type QueryAllPlayerInfoRequest struct { + Pagination *query.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"` +} + +func (m *QueryAllPlayerInfoRequest) Reset() { *m = QueryAllPlayerInfoRequest{} } +func (m *QueryAllPlayerInfoRequest) String() string { return proto.CompactTextString(m) } +func (*QueryAllPlayerInfoRequest) ProtoMessage() {} +func (*QueryAllPlayerInfoRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_3c482788bba85e7a, []int{12} +} +func (m *QueryAllPlayerInfoRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryAllPlayerInfoRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryAllPlayerInfoRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *QueryAllPlayerInfoRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryAllPlayerInfoRequest.Merge(m, src) +} +func (m *QueryAllPlayerInfoRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryAllPlayerInfoRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryAllPlayerInfoRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryAllPlayerInfoRequest proto.InternalMessageInfo + +func (m *QueryAllPlayerInfoRequest) GetPagination() *query.PageRequest { + if m != nil { + return m.Pagination + } + return nil +} + +type QueryAllPlayerInfoResponse struct { + PlayerInfo []PlayerInfo `protobuf:"bytes,1,rep,name=playerInfo,proto3" json:"playerInfo"` + Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"` +} + +func (m *QueryAllPlayerInfoResponse) Reset() { *m = QueryAllPlayerInfoResponse{} } +func (m *QueryAllPlayerInfoResponse) String() string { return proto.CompactTextString(m) } +func (*QueryAllPlayerInfoResponse) ProtoMessage() {} +func (*QueryAllPlayerInfoResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_3c482788bba85e7a, []int{13} +} +func (m *QueryAllPlayerInfoResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryAllPlayerInfoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryAllPlayerInfoResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *QueryAllPlayerInfoResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryAllPlayerInfoResponse.Merge(m, src) +} +func (m *QueryAllPlayerInfoResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryAllPlayerInfoResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryAllPlayerInfoResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryAllPlayerInfoResponse proto.InternalMessageInfo + +func (m *QueryAllPlayerInfoResponse) GetPlayerInfo() []PlayerInfo { + if m != nil { + return m.PlayerInfo + } + return nil +} + +func (m *QueryAllPlayerInfoResponse) GetPagination() *query.PageResponse { + if m != nil { + return m.Pagination + } + return nil +} + func init() { proto.RegisterType((*QueryParamsRequest)(nil), "b9lab.checkers.checkers.QueryParamsRequest") proto.RegisterType((*QueryParamsResponse)(nil), "b9lab.checkers.checkers.QueryParamsResponse") @@ -524,59 +708,68 @@ func init() { proto.RegisterType((*QueryAllStoredGameResponse)(nil), "b9lab.checkers.checkers.QueryAllStoredGameResponse") proto.RegisterType((*QueryCanPlayMoveRequest)(nil), "b9lab.checkers.checkers.QueryCanPlayMoveRequest") proto.RegisterType((*QueryCanPlayMoveResponse)(nil), "b9lab.checkers.checkers.QueryCanPlayMoveResponse") + proto.RegisterType((*QueryGetPlayerInfoRequest)(nil), "b9lab.checkers.checkers.QueryGetPlayerInfoRequest") + proto.RegisterType((*QueryGetPlayerInfoResponse)(nil), "b9lab.checkers.checkers.QueryGetPlayerInfoResponse") + proto.RegisterType((*QueryAllPlayerInfoRequest)(nil), "b9lab.checkers.checkers.QueryAllPlayerInfoRequest") + proto.RegisterType((*QueryAllPlayerInfoResponse)(nil), "b9lab.checkers.checkers.QueryAllPlayerInfoResponse") } func init() { proto.RegisterFile("checkers/query.proto", fileDescriptor_3c482788bba85e7a) } var fileDescriptor_3c482788bba85e7a = []byte{ - // 740 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x95, 0x4d, 0x4f, 0xd4, 0x40, - 0x18, 0xc7, 0xb7, 0xbc, 0x6c, 0xd8, 0x21, 0x26, 0x66, 0x5c, 0x65, 0xad, 0x64, 0xc1, 0x6a, 0x80, - 0x20, 0xe9, 0xb8, 0xe0, 0xc5, 0x83, 0x07, 0xd0, 0x48, 0x38, 0x68, 0xb0, 0x9a, 0xc8, 0x7a, 0xd9, - 0x4c, 0x97, 0xa1, 0x34, 0xb6, 0x9d, 0xd2, 0x29, 0x84, 0xcd, 0x66, 0x2f, 0x9e, 0x3d, 0x98, 0xf8, - 0x01, 0x3c, 0x98, 0x78, 0xf1, 0xe2, 0xc7, 0xe0, 0x48, 0xc2, 0xc5, 0x93, 0x31, 0xe0, 0xc5, 0x6f, - 0x61, 0x3a, 0x33, 0x7d, 0xd9, 0x97, 0xb2, 0x8b, 0x17, 0x98, 0x79, 0xe6, 0x79, 0xe6, 0xff, 0xeb, - 0xcc, 0xf3, 0x9f, 0x05, 0xe5, 0xe6, 0x3e, 0x69, 0xbe, 0x27, 0x01, 0x43, 0x07, 0x87, 0x24, 0x68, - 0xe9, 0x7e, 0x40, 0x43, 0x0a, 0x67, 0xcc, 0xc7, 0x0e, 0x36, 0xf5, 0x78, 0x2d, 0x19, 0xa8, 0x65, - 0x8b, 0x5a, 0x94, 0xe7, 0xa0, 0x68, 0x24, 0xd2, 0xd5, 0x59, 0x8b, 0x52, 0xcb, 0x21, 0x08, 0xfb, - 0x36, 0xc2, 0x9e, 0x47, 0x43, 0x1c, 0xda, 0xd4, 0x63, 0x72, 0x75, 0xb9, 0x49, 0x99, 0x4b, 0x19, - 0x32, 0x31, 0x23, 0x42, 0x05, 0x1d, 0xd5, 0x4c, 0x12, 0xe2, 0x1a, 0xf2, 0xb1, 0x65, 0x7b, 0x3c, - 0x59, 0xe6, 0xde, 0x4c, 0x70, 0x7c, 0x1c, 0x60, 0x37, 0xde, 0x42, 0x4d, 0xc2, 0xac, 0xc5, 0x42, - 0xe2, 0x36, 0x6c, 0x6f, 0x8f, 0xf6, 0xaf, 0x85, 0x34, 0x20, 0xbb, 0x0d, 0x0b, 0xbb, 0x44, 0xac, - 0x69, 0x65, 0x00, 0x5f, 0x45, 0x82, 0xdb, 0x7c, 0x33, 0x83, 0x1c, 0x1c, 0x12, 0x16, 0x6a, 0x6f, - 0xc0, 0x8d, 0xae, 0x28, 0xf3, 0xa9, 0xc7, 0x08, 0x7c, 0x02, 0x8a, 0x42, 0xb4, 0xa2, 0xcc, 0x2b, - 0x4b, 0xd3, 0xab, 0x73, 0x7a, 0xce, 0x29, 0xe8, 0xa2, 0x70, 0x63, 0xe2, 0xe4, 0xd7, 0x5c, 0xc1, - 0x90, 0x45, 0xda, 0x1d, 0x70, 0x9b, 0xef, 0xba, 0x49, 0xc2, 0xd7, 0x1c, 0x72, 0xcb, 0xdb, 0xa3, - 0xb1, 0xa4, 0x05, 0xd4, 0x41, 0x8b, 0x52, 0x79, 0x0b, 0x80, 0x34, 0x2a, 0xd5, 0xef, 0xe5, 0xaa, - 0xa7, 0xa9, 0x92, 0x20, 0x53, 0xac, 0xd5, 0x32, 0x14, 0xfc, 0x38, 0x36, 0xb1, 0x4b, 0x24, 0x05, - 0x2c, 0x83, 0x49, 0xdb, 0xdb, 0x25, 0xc7, 0x5c, 0xa2, 0x64, 0x88, 0x49, 0x17, 0x5b, 0xa6, 0x24, - 0x65, 0x63, 0x49, 0x74, 0x38, 0x5b, 0x92, 0x1a, 0xb3, 0xa5, 0xc5, 0x5a, 0x53, 0xb2, 0xad, 0x3b, - 0x4e, 0x3f, 0xdb, 0x73, 0x00, 0xd2, 0x6e, 0x90, 0x3a, 0x0b, 0xba, 0x68, 0x1d, 0x3d, 0x6a, 0x1d, - 0x5d, 0x34, 0xa8, 0x6c, 0x1d, 0x7d, 0x1b, 0x5b, 0x71, 0xad, 0x91, 0xa9, 0xd4, 0x7e, 0x28, 0xf2, - 0x73, 0x7a, 0x54, 0x72, 0x3e, 0x67, 0xfc, 0xbf, 0x3f, 0x07, 0x6e, 0x76, 0x11, 0x8f, 0x71, 0xe2, - 0xc5, 0xa1, 0xc4, 0x82, 0xa3, 0x0b, 0xf9, 0x8b, 0x02, 0x66, 0x38, 0xf2, 0x53, 0xec, 0x6d, 0x3b, - 0xb8, 0xf5, 0x82, 0x1e, 0x25, 0xc7, 0x32, 0x0b, 0x4a, 0x51, 0x3f, 0x6f, 0x65, 0xae, 0x2d, 0x0d, - 0xc0, 0x5b, 0xa0, 0xe8, 0x3b, 0xb8, 0x45, 0x02, 0x2e, 0x5f, 0x32, 0xe4, 0x2c, 0xba, 0xe8, 0xbd, - 0x80, 0xba, 0x3b, 0x95, 0xf1, 0x79, 0x65, 0x69, 0xc2, 0x10, 0x93, 0x38, 0x5a, 0xaf, 0x4c, 0xa4, - 0xd1, 0x3a, 0xbc, 0x0e, 0xc6, 0x43, 0xba, 0x53, 0x99, 0xe4, 0xb1, 0x68, 0x28, 0x22, 0xf5, 0x4a, - 0x31, 0x8e, 0xd4, 0xb5, 0x97, 0xa0, 0xd2, 0x0f, 0x28, 0x4f, 0x54, 0x05, 0x53, 0x3e, 0x65, 0xcc, - 0x36, 0x1d, 0xd1, 0x1e, 0x53, 0x46, 0x32, 0x8f, 0xf8, 0x02, 0x82, 0x99, 0x3c, 0x9e, 0x92, 0x21, - 0x67, 0xab, 0x7f, 0x8b, 0x60, 0x92, 0x6f, 0x08, 0x3f, 0x2a, 0xa0, 0x28, 0xec, 0x04, 0x1f, 0xe4, - 0x5e, 0x43, 0xbf, 0x87, 0xd5, 0x95, 0xd1, 0x92, 0x05, 0xa3, 0xb6, 0xf8, 0xe1, 0xec, 0xcf, 0xe7, - 0xb1, 0xbb, 0x70, 0x0e, 0xf1, 0x2a, 0x94, 0x3c, 0x19, 0x3d, 0xcf, 0x0d, 0xfc, 0xaa, 0x64, 0xad, - 0x08, 0x57, 0x2f, 0x57, 0x19, 0x64, 0x75, 0x75, 0xed, 0x4a, 0x35, 0x12, 0x70, 0x85, 0x03, 0x2e, - 0xc0, 0xfb, 0xb9, 0x80, 0x99, 0x87, 0x0f, 0x7e, 0x8f, 0x28, 0xd3, 0x46, 0x1c, 0x81, 0xb2, 0xd7, - 0x6e, 0xa3, 0x50, 0xf6, 0x99, 0x47, 0x7b, 0xc4, 0x29, 0x75, 0xb8, 0x92, 0x4f, 0x99, 0x3e, 0xc1, - 0xa8, 0xcd, 0x9f, 0x97, 0x0e, 0xfc, 0xa6, 0x80, 0x6b, 0xe9, 0x66, 0xeb, 0x8e, 0x33, 0x0c, 0x78, - 0xd0, 0xfb, 0x30, 0x0c, 0x78, 0xa0, 0xdb, 0x47, 0x39, 0xd6, 0x14, 0x18, 0x9e, 0x29, 0x60, 0x3a, - 0xd3, 0xe1, 0xf0, 0xe1, 0xe5, 0x92, 0xfd, 0x6e, 0x55, 0x6b, 0x57, 0xa8, 0x90, 0x88, 0x0d, 0x8e, - 0x58, 0x87, 0x6f, 0x73, 0x11, 0x9b, 0xd8, 0x6b, 0x44, 0xbe, 0x6e, 0xb8, 0xf4, 0x88, 0xa0, 0x76, - 0xe2, 0xfe, 0x0e, 0x6a, 0x0b, 0xbb, 0x77, 0x50, 0x9b, 0x1b, 0x5c, 0xfe, 0xaf, 0x77, 0x50, 0x3b, - 0xa4, 0x3b, 0xfc, 0x6f, 0xbd, 0xb3, 0xf1, 0xec, 0xe4, 0xbc, 0xaa, 0x9c, 0x9e, 0x57, 0x95, 0xdf, - 0xe7, 0x55, 0xe5, 0xd3, 0x45, 0xb5, 0x70, 0x7a, 0x51, 0x2d, 0xfc, 0xbc, 0xa8, 0x16, 0xde, 0x2d, - 0x5b, 0x76, 0xb8, 0x7f, 0x68, 0xea, 0x4d, 0xea, 0xf6, 0x8a, 0x1f, 0xa7, 0xc3, 0xb0, 0xe5, 0x13, - 0x66, 0x16, 0xf9, 0x0f, 0xea, 0xda, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xbe, 0xfd, 0x39, 0x18, - 0x30, 0x08, 0x00, 0x00, + // 829 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x96, 0xc1, 0x4f, 0xdb, 0x3a, + 0x1c, 0xc7, 0x1b, 0x0a, 0x15, 0x35, 0x7a, 0xd2, 0x93, 0x5f, 0xdf, 0xa3, 0x2f, 0x43, 0x85, 0x65, + 0x13, 0x20, 0x86, 0x92, 0x15, 0x76, 0xd9, 0x61, 0x07, 0xd8, 0x34, 0xc4, 0x61, 0x53, 0x97, 0x4d, + 0x1a, 0xdd, 0xa5, 0x72, 0x8b, 0x09, 0xd5, 0x92, 0x38, 0x24, 0x01, 0x51, 0x55, 0xbd, 0xec, 0xbc, + 0xc3, 0xa4, 0xfd, 0x01, 0x3b, 0x4c, 0xda, 0x65, 0x97, 0xfd, 0x09, 0x3b, 0x72, 0x44, 0xe2, 0xb2, + 0xd3, 0x34, 0xc1, 0xfe, 0x90, 0x29, 0xb6, 0x13, 0xbb, 0x4d, 0x4b, 0x03, 0xda, 0x2e, 0x60, 0xff, + 0xec, 0x9f, 0x7f, 0x1f, 0xdb, 0x5f, 0x7f, 0x53, 0x50, 0x6a, 0xed, 0xe3, 0xd6, 0x6b, 0xec, 0x07, + 0xc6, 0xc1, 0x21, 0xf6, 0x3b, 0xba, 0xe7, 0x93, 0x90, 0xc0, 0xd9, 0xe6, 0x7d, 0x1b, 0x35, 0xf5, + 0x78, 0x2c, 0x69, 0xa8, 0x25, 0x8b, 0x58, 0x84, 0xce, 0x31, 0xa2, 0x16, 0x9b, 0xae, 0xce, 0x59, + 0x84, 0x58, 0x36, 0x36, 0x90, 0xd7, 0x36, 0x90, 0xeb, 0x92, 0x10, 0x85, 0x6d, 0xe2, 0x06, 0x7c, + 0x74, 0xa5, 0x45, 0x02, 0x87, 0x04, 0x46, 0x13, 0x05, 0x98, 0x55, 0x31, 0x8e, 0xaa, 0x4d, 0x1c, + 0xa2, 0xaa, 0xe1, 0x21, 0xab, 0xed, 0xd2, 0xc9, 0x7c, 0xee, 0xbf, 0x09, 0x8e, 0x87, 0x7c, 0xe4, + 0xc4, 0x4b, 0xa8, 0x49, 0x38, 0xe8, 0x04, 0x21, 0x76, 0x1a, 0x6d, 0x77, 0x8f, 0xa4, 0xc7, 0x42, + 0xe2, 0xe3, 0xdd, 0x86, 0x85, 0x1c, 0x9c, 0x1a, 0xf3, 0x6c, 0xd4, 0xc1, 0xbe, 0x94, 0xa7, 0x95, + 0x00, 0x7c, 0x16, 0xc1, 0xd4, 0x68, 0x21, 0x13, 0x1f, 0x1c, 0xe2, 0x20, 0xd4, 0x5e, 0x80, 0x7f, + 0xfa, 0xa2, 0x81, 0x47, 0xdc, 0x00, 0xc3, 0x07, 0xa0, 0xc0, 0x80, 0xca, 0xca, 0x82, 0xb2, 0x3c, + 0xb3, 0x36, 0xaf, 0x8f, 0x38, 0x21, 0x9d, 0x25, 0x6e, 0x4e, 0x9e, 0x7c, 0x9f, 0xcf, 0x99, 0x3c, + 0x49, 0xbb, 0x01, 0xfe, 0xa7, 0xab, 0x6e, 0xe1, 0xf0, 0x39, 0xdd, 0xc0, 0xb6, 0xbb, 0x47, 0xe2, + 0x92, 0x16, 0x50, 0x87, 0x0d, 0xf2, 0xca, 0xdb, 0x00, 0x88, 0x28, 0xaf, 0x7e, 0x6b, 0x64, 0x75, + 0x31, 0x95, 0x13, 0x48, 0xc9, 0x5a, 0x55, 0xa2, 0xa0, 0x47, 0xb5, 0x85, 0x1c, 0xcc, 0x29, 0x60, + 0x09, 0x4c, 0xb5, 0xdd, 0x5d, 0x7c, 0x4c, 0x4b, 0x14, 0x4d, 0xd6, 0xe9, 0x63, 0x93, 0x52, 0x04, + 0x5b, 0x90, 0x44, 0xc7, 0xb3, 0x25, 0x53, 0x63, 0x36, 0x91, 0xac, 0xb5, 0x38, 0xdb, 0x86, 0x6d, + 0xa7, 0xd9, 0x1e, 0x03, 0x20, 0x94, 0xc2, 0xeb, 0x2c, 0xea, 0x4c, 0x56, 0x7a, 0x24, 0x2b, 0x9d, + 0x89, 0x97, 0xcb, 0x4a, 0xaf, 0x21, 0x2b, 0xce, 0x35, 0xa5, 0x4c, 0xed, 0x8b, 0xc2, 0xb7, 0x33, + 0x50, 0x65, 0xc4, 0x76, 0xf2, 0xd7, 0xde, 0x0e, 0xdc, 0xea, 0x23, 0x9e, 0xa0, 0xc4, 0x4b, 0x63, + 0x89, 0x19, 0x47, 0x1f, 0xf2, 0x07, 0x05, 0xcc, 0x52, 0xe4, 0x87, 0xc8, 0xad, 0xd9, 0xa8, 0xf3, + 0x84, 0x1c, 0x25, 0xc7, 0x32, 0x07, 0x8a, 0x91, 0xd6, 0xb7, 0xa5, 0x6b, 0x13, 0x01, 0xf8, 0x1f, + 0x28, 0x30, 0xd1, 0xd3, 0xf2, 0x45, 0x93, 0xf7, 0xa2, 0x8b, 0xde, 0xf3, 0x89, 0xb3, 0x53, 0xce, + 0x2f, 0x28, 0xcb, 0x93, 0x26, 0xeb, 0xc4, 0xd1, 0x7a, 0x79, 0x52, 0x44, 0xeb, 0xf0, 0x6f, 0x90, + 0x0f, 0xc9, 0x4e, 0x79, 0x8a, 0xc6, 0xa2, 0x26, 0x8b, 0xd4, 0xcb, 0x85, 0x38, 0x52, 0xd7, 0x9e, + 0x82, 0x72, 0x1a, 0x90, 0x9f, 0xa8, 0x0a, 0xa6, 0x3d, 0x12, 0x04, 0xed, 0xa6, 0xcd, 0xe4, 0x31, + 0x6d, 0x26, 0xfd, 0x88, 0xcf, 0xc7, 0x28, 0xe0, 0xc7, 0x53, 0x34, 0x79, 0x4f, 0x56, 0x69, 0x8d, + 0x12, 0x4b, 0x6f, 0x65, 0xbc, 0x4a, 0xe5, 0x14, 0x71, 0xad, 0x5e, 0x12, 0x1d, 0xab, 0x52, 0xb1, + 0x40, 0x7c, 0xad, 0x22, 0x59, 0x56, 0x69, 0x9a, 0xed, 0x4f, 0xa8, 0x34, 0xc3, 0x76, 0xf2, 0xd7, + 0xde, 0xce, 0x6f, 0x53, 0xe9, 0xda, 0xd7, 0x22, 0x98, 0xa2, 0xc8, 0xf0, 0xad, 0x02, 0x0a, 0xcc, + 0x02, 0xe1, 0x9d, 0x91, 0x50, 0x69, 0xdf, 0x55, 0x57, 0xb3, 0x4d, 0x66, 0xb5, 0xb5, 0xa5, 0x37, + 0x67, 0x3f, 0xdf, 0x4f, 0xdc, 0x84, 0xf3, 0x06, 0xcd, 0x32, 0x12, 0x9b, 0x1f, 0xf8, 0x7c, 0xc0, + 0x8f, 0x8a, 0x6c, 0x9f, 0x70, 0xed, 0xf2, 0x2a, 0xc3, 0xec, 0x59, 0x5d, 0xbf, 0x52, 0x0e, 0x07, + 0x5c, 0xa5, 0x80, 0x8b, 0xf0, 0xf6, 0x48, 0x40, 0xe9, 0x43, 0x06, 0x3f, 0x47, 0x94, 0xc2, 0x3c, + 0x32, 0x50, 0x0e, 0x5a, 0x64, 0x16, 0xca, 0x94, 0xe1, 0x69, 0xf7, 0x28, 0xa5, 0x0e, 0x57, 0x47, + 0x53, 0x8a, 0x4f, 0xaa, 0xd1, 0xa5, 0x8f, 0xad, 0x07, 0x3f, 0x29, 0xe0, 0x2f, 0xb1, 0xd8, 0x86, + 0x6d, 0x8f, 0x03, 0x1e, 0xe6, 0xe9, 0xe3, 0x80, 0x87, 0x3a, 0x74, 0x96, 0x63, 0x15, 0xc0, 0xf0, + 0x4c, 0x01, 0x33, 0x92, 0x2b, 0xc1, 0xbb, 0x97, 0x97, 0x4c, 0x3b, 0xac, 0x5a, 0xbd, 0x42, 0x06, + 0x47, 0x6c, 0x50, 0xc4, 0x3a, 0x7c, 0x39, 0x12, 0xb1, 0x85, 0xdc, 0x46, 0xf4, 0x08, 0x1b, 0x0e, + 0x39, 0xc2, 0x46, 0x37, 0x71, 0xec, 0x9e, 0xd1, 0x65, 0x6f, 0xb3, 0x67, 0x74, 0xa9, 0x29, 0xf3, + 0xff, 0xf5, 0x9e, 0xd1, 0x0d, 0xc9, 0x0e, 0xfd, 0x5b, 0xef, 0x51, 0xb1, 0x88, 0x57, 0x9d, 0x41, + 0x2c, 0x29, 0xa7, 0xca, 0x20, 0x96, 0xb4, 0xef, 0x64, 0x10, 0x8b, 0xf4, 0x1b, 0xab, 0x4f, 0x2c, + 0x62, 0xb1, 0x6c, 0x62, 0xb9, 0x32, 0xf0, 0x50, 0xa3, 0xcc, 0x20, 0x16, 0x09, 0x78, 0xf3, 0xd1, + 0xc9, 0x79, 0x45, 0x39, 0x3d, 0xaf, 0x28, 0x3f, 0xce, 0x2b, 0xca, 0xbb, 0x8b, 0x4a, 0xee, 0xf4, + 0xa2, 0x92, 0xfb, 0x76, 0x51, 0xc9, 0xbd, 0x5a, 0xb1, 0xda, 0xe1, 0xfe, 0x61, 0x53, 0x6f, 0x11, + 0x67, 0x70, 0xa5, 0x63, 0xd1, 0x0c, 0x3b, 0x1e, 0x0e, 0x9a, 0x05, 0xfa, 0xdb, 0x72, 0xfd, 0x57, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xe7, 0x52, 0xd1, 0xb6, 0x57, 0x0b, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -601,6 +794,10 @@ type QueryClient interface { StoredGameAll(ctx context.Context, in *QueryAllStoredGameRequest, opts ...grpc.CallOption) (*QueryAllStoredGameResponse, error) // Queries a list of CanPlayMove items. CanPlayMove(ctx context.Context, in *QueryCanPlayMoveRequest, opts ...grpc.CallOption) (*QueryCanPlayMoveResponse, error) + // Queries a PlayerInfo by index. + PlayerInfo(ctx context.Context, in *QueryGetPlayerInfoRequest, opts ...grpc.CallOption) (*QueryGetPlayerInfoResponse, error) + // Queries a list of PlayerInfo items. + PlayerInfoAll(ctx context.Context, in *QueryAllPlayerInfoRequest, opts ...grpc.CallOption) (*QueryAllPlayerInfoResponse, error) } type queryClient struct { @@ -656,6 +853,24 @@ func (c *queryClient) CanPlayMove(ctx context.Context, in *QueryCanPlayMoveReque return out, nil } +func (c *queryClient) PlayerInfo(ctx context.Context, in *QueryGetPlayerInfoRequest, opts ...grpc.CallOption) (*QueryGetPlayerInfoResponse, error) { + out := new(QueryGetPlayerInfoResponse) + err := c.cc.Invoke(ctx, "/b9lab.checkers.checkers.Query/PlayerInfo", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) PlayerInfoAll(ctx context.Context, in *QueryAllPlayerInfoRequest, opts ...grpc.CallOption) (*QueryAllPlayerInfoResponse, error) { + out := new(QueryAllPlayerInfoResponse) + err := c.cc.Invoke(ctx, "/b9lab.checkers.checkers.Query/PlayerInfoAll", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + // QueryServer is the server API for Query service. type QueryServer interface { // Parameters queries the parameters of the module. @@ -668,6 +883,10 @@ type QueryServer interface { StoredGameAll(context.Context, *QueryAllStoredGameRequest) (*QueryAllStoredGameResponse, error) // Queries a list of CanPlayMove items. CanPlayMove(context.Context, *QueryCanPlayMoveRequest) (*QueryCanPlayMoveResponse, error) + // Queries a PlayerInfo by index. + PlayerInfo(context.Context, *QueryGetPlayerInfoRequest) (*QueryGetPlayerInfoResponse, error) + // Queries a list of PlayerInfo items. + PlayerInfoAll(context.Context, *QueryAllPlayerInfoRequest) (*QueryAllPlayerInfoResponse, error) } // UnimplementedQueryServer can be embedded to have forward compatible implementations. @@ -689,6 +908,12 @@ func (*UnimplementedQueryServer) StoredGameAll(ctx context.Context, req *QueryAl func (*UnimplementedQueryServer) CanPlayMove(ctx context.Context, req *QueryCanPlayMoveRequest) (*QueryCanPlayMoveResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method CanPlayMove not implemented") } +func (*UnimplementedQueryServer) PlayerInfo(ctx context.Context, req *QueryGetPlayerInfoRequest) (*QueryGetPlayerInfoResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method PlayerInfo not implemented") +} +func (*UnimplementedQueryServer) PlayerInfoAll(ctx context.Context, req *QueryAllPlayerInfoRequest) (*QueryAllPlayerInfoResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method PlayerInfoAll not implemented") +} func RegisterQueryServer(s grpc1.Server, srv QueryServer) { s.RegisterService(&_Query_serviceDesc, srv) @@ -784,6 +1009,42 @@ func _Query_CanPlayMove_Handler(srv interface{}, ctx context.Context, dec func(i return interceptor(ctx, in, info, handler) } +func _Query_PlayerInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryGetPlayerInfoRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).PlayerInfo(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/b9lab.checkers.checkers.Query/PlayerInfo", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).PlayerInfo(ctx, req.(*QueryGetPlayerInfoRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_PlayerInfoAll_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryAllPlayerInfoRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).PlayerInfoAll(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/b9lab.checkers.checkers.Query/PlayerInfoAll", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).PlayerInfoAll(ctx, req.(*QueryAllPlayerInfoRequest)) + } + return interceptor(ctx, in, info, handler) +} + var _Query_serviceDesc = grpc.ServiceDesc{ ServiceName: "b9lab.checkers.checkers.Query", HandlerType: (*QueryServer)(nil), @@ -808,6 +1069,14 @@ var _Query_serviceDesc = grpc.ServiceDesc{ MethodName: "CanPlayMove", Handler: _Query_CanPlayMove_Handler, }, + { + MethodName: "PlayerInfo", + Handler: _Query_PlayerInfo_Handler, + }, + { + MethodName: "PlayerInfoAll", + Handler: _Query_PlayerInfoAll_Handler, + }, }, Streams: []grpc.StreamDesc{}, Metadata: "checkers/query.proto", @@ -1169,79 +1438,226 @@ func (m *QueryCanPlayMoveResponse) MarshalToSizedBuffer(dAtA []byte) (int, error return len(dAtA) - i, nil } -func encodeVarintQuery(dAtA []byte, offset int, v uint64) int { - offset -= sovQuery(v) - base := offset - for v >= 1<<7 { - dAtA[offset] = uint8(v&0x7f | 0x80) - v >>= 7 - offset++ +func (m *QueryGetPlayerInfoRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - dAtA[offset] = uint8(v) - return base + return dAtA[:n], nil } -func (m *QueryParamsRequest) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - return n + +func (m *QueryGetPlayerInfoRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *QueryParamsResponse) Size() (n int) { - if m == nil { - return 0 - } +func (m *QueryGetPlayerInfoRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - l = m.Params.Size() - n += 1 + l + sovQuery(uint64(l)) - return n + if len(m.Index) > 0 { + i -= len(m.Index) + copy(dAtA[i:], m.Index) + i = encodeVarintQuery(dAtA, i, uint64(len(m.Index))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil } -func (m *QueryGetSystemInfoRequest) Size() (n int) { - if m == nil { - return 0 +func (m *QueryGetPlayerInfoResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - var l int - _ = l - return n + return dAtA[:n], nil } -func (m *QueryGetSystemInfoResponse) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = m.SystemInfo.Size() - n += 1 + l + sovQuery(uint64(l)) - return n +func (m *QueryGetPlayerInfoResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *QueryGetStoredGameRequest) Size() (n int) { - if m == nil { - return 0 - } +func (m *QueryGetPlayerInfoResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - l = len(m.Index) - if l > 0 { - n += 1 + l + sovQuery(uint64(l)) + { + size, err := m.PlayerInfo.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) } - return n + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil } -func (m *QueryGetStoredGameResponse) Size() (n int) { - if m == nil { - return 0 +func (m *QueryAllPlayerInfoRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - var l int - _ = l - l = m.StoredGame.Size() - n += 1 + l + sovQuery(uint64(l)) - return n + return dAtA[:n], nil +} + +func (m *QueryAllPlayerInfoRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryAllPlayerInfoRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Pagination != nil { + { + size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryAllPlayerInfoResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *QueryAllPlayerInfoResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryAllPlayerInfoResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Pagination != nil { + { + size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.PlayerInfo) > 0 { + for iNdEx := len(m.PlayerInfo) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.PlayerInfo[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func encodeVarintQuery(dAtA []byte, offset int, v uint64) int { + offset -= sovQuery(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *QueryParamsRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *QueryParamsResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Params.Size() + n += 1 + l + sovQuery(uint64(l)) + return n +} + +func (m *QueryGetSystemInfoRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *QueryGetSystemInfoResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.SystemInfo.Size() + n += 1 + l + sovQuery(uint64(l)) + return n +} + +func (m *QueryGetStoredGameRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Index) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryGetStoredGameResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.StoredGame.Size() + n += 1 + l + sovQuery(uint64(l)) + return n } func (m *QueryAllStoredGameRequest) Size() (n int) { @@ -1321,6 +1737,62 @@ func (m *QueryCanPlayMoveResponse) Size() (n int) { return n } +func (m *QueryGetPlayerInfoRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Index) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryGetPlayerInfoResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.PlayerInfo.Size() + n += 1 + l + sovQuery(uint64(l)) + return n +} + +func (m *QueryAllPlayerInfoRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Pagination != nil { + l = m.Pagination.Size() + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryAllPlayerInfoResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.PlayerInfo) > 0 { + for _, e := range m.PlayerInfo { + l = e.Size() + n += 1 + l + sovQuery(uint64(l)) + } + } + if m.Pagination != nil { + l = m.Pagination.Size() + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + func sovQuery(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } @@ -2256,6 +2728,377 @@ func (m *QueryCanPlayMoveResponse) Unmarshal(dAtA []byte) error { } return nil } +func (m *QueryGetPlayerInfoRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryGetPlayerInfoRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryGetPlayerInfoRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Index = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryGetPlayerInfoResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryGetPlayerInfoResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryGetPlayerInfoResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PlayerInfo", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.PlayerInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryAllPlayerInfoRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryAllPlayerInfoRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryAllPlayerInfoRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Pagination == nil { + m.Pagination = &query.PageRequest{} + } + if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryAllPlayerInfoResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryAllPlayerInfoResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryAllPlayerInfoResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PlayerInfo", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PlayerInfo = append(m.PlayerInfo, PlayerInfo{}) + if err := m.PlayerInfo[len(m.PlayerInfo)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Pagination == nil { + m.Pagination = &query.PageResponse{} + } + if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func skipQuery(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/checkers/types/query.pb.gw.go b/x/checkers/types/query.pb.gw.go index 6052303..e728202 100644 --- a/x/checkers/types/query.pb.gw.go +++ b/x/checkers/types/query.pb.gw.go @@ -323,6 +323,96 @@ func local_request_Query_CanPlayMove_0(ctx context.Context, marshaler runtime.Ma } +func request_Query_PlayerInfo_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryGetPlayerInfoRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["index"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "index") + } + + protoReq.Index, err = runtime.String(val) + + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "index", err) + } + + msg, err := client.PlayerInfo(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Query_PlayerInfo_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryGetPlayerInfoRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["index"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "index") + } + + protoReq.Index, err = runtime.String(val) + + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "index", err) + } + + msg, err := server.PlayerInfo(ctx, &protoReq) + return msg, metadata, err + +} + +var ( + filter_Query_PlayerInfoAll_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} +) + +func request_Query_PlayerInfoAll_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryAllPlayerInfoRequest + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_PlayerInfoAll_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.PlayerInfoAll(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Query_PlayerInfoAll_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryAllPlayerInfoRequest + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_PlayerInfoAll_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.PlayerInfoAll(ctx, &protoReq) + return msg, metadata, err + +} + // RegisterQueryHandlerServer registers the http handlers for service Query to "mux". // UnaryRPC :call QueryServer directly. // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. @@ -444,6 +534,52 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv }) + mux.Handle("GET", pattern_Query_PlayerInfo_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_Query_PlayerInfo_0(rctx, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_PlayerInfo_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_Query_PlayerInfoAll_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_Query_PlayerInfoAll_0(rctx, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_PlayerInfoAll_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + return nil } @@ -585,6 +721,46 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie }) + mux.Handle("GET", pattern_Query_PlayerInfo_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_Query_PlayerInfo_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_PlayerInfo_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_Query_PlayerInfoAll_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_Query_PlayerInfoAll_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_PlayerInfoAll_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + return nil } @@ -598,6 +774,10 @@ var ( pattern_Query_StoredGameAll_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 1, 2, 2}, []string{"b9lab", "checkers", "stored_game"}, "", runtime.AssumeColonVerbOpt(true))) pattern_Query_CanPlayMove_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 1, 0, 4, 1, 5, 4, 1, 0, 4, 1, 5, 5, 1, 0, 4, 1, 5, 6, 1, 0, 4, 1, 5, 7, 1, 0, 4, 1, 5, 8}, []string{"b9lab", "checkers", "can_play_move", "gameIndex", "player", "fromX", "fromY", "toX", "toY"}, "", runtime.AssumeColonVerbOpt(true))) + + pattern_Query_PlayerInfo_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"b9lab", "checkers", "player_info", "index"}, "", runtime.AssumeColonVerbOpt(true))) + + pattern_Query_PlayerInfoAll_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 1, 2, 2}, []string{"b9lab", "checkers", "player_info"}, "", runtime.AssumeColonVerbOpt(true))) ) var ( @@ -610,4 +790,8 @@ var ( forward_Query_StoredGameAll_0 = runtime.ForwardResponseMessage forward_Query_CanPlayMove_0 = runtime.ForwardResponseMessage + + forward_Query_PlayerInfo_0 = runtime.ForwardResponseMessage + + forward_Query_PlayerInfoAll_0 = runtime.ForwardResponseMessage )