jeirmeister/Cockatrice
1
0
Fork 0
mirror of https://github.com/Cockatrice/Cockatrice.git synced 2026-06-12 00:54:53 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

remove type aliases

Browse source
This commit is contained in:
seavor 2026-04-14 15:14:43 -05:00
parent 141f0e59f5
commit cea9ae62d8
58 changed files with 412 additions and 455 deletions
Download patch file Download diff file Expand all files Collapse all files

7
webclient/src/store/common/SortUtil.ts
View file

@ -1,4 +1,5 @@
import { SortBy, SortDirection, User } from 'types';
import { SortBy, SortDirection } from 'types';
import type { ServerInfo_User } from 'generated/proto/serverinfo_user_pb';
export default class SortUtil {
static sortByField<T extends object>(arr: T[], sortBy: SortBy): void {
@ -51,7 +52,7 @@ export default class SortUtil {
}
}
static sortUsersByField(users: User[], sortBy: SortBy) {
static sortUsersByField(users: ServerInfo_User[], sortBy: SortBy) {
if (users.length) {
users.sort((a, b) => SortUtil.userComparator(a, b, sortBy))
}
@ -75,7 +76,7 @@ export default class SortUtil {
arr.sort((a, b) => SortUtil.stringComparator(a, b, sortBy));
}
private static userComparator(a: User, b: User, sortBy: SortBy, sortByUserLevel = true) {
private static userComparator(a: ServerInfo_User, b: ServerInfo_User, sortBy: SortBy, sortByUserLevel = true) {
if (sortByUserLevel) {
const adminSortBy = {
field: 'userLevel',

5
webclient/src/store/common/normalizers.ts
View file

@ -1,7 +1,8 @@
import type { ServerInfo_Room } from 'generated/proto/serverinfo_room_pb';
import type { ServerInfo_Game } from 'generated/proto/serverinfo_game_pb';
import type { ServerInfo_GameType } from 'generated/proto/serverinfo_gametype_pb';
import { Game, GametypeMap, LogItem, LogGroups, Message, Room } from 'types';
import type { ServerInfo_ChatMessage } from 'generated/proto/serverinfo_chat_message_pb';
import { Game, GametypeMap, LogGroups, Message, Room } from 'types';
/** Flatten a gametype list into a lookup map of { gameTypeId → description }. */
export function normalizeGametypeMap(gametypeList: ServerInfo_GameType[]): GametypeMap {
@ -40,7 +41,7 @@ export function normalizeGameObject(game: ServerInfo_Game, gametypeMap: Gametype
}
/** Group a flat LogItem[] into { room, game, chat } buckets for the server store. */
export function normalizeLogs(logs: LogItem[]): LogGroups {
export function normalizeLogs(logs: ServerInfo_ChatMessage[]): LogGroups {
return logs.reduce((obj, log) => {
const type = log.targetType as keyof LogGroups;
obj[type] = obj[type] || [];

14
webclient/src/store/game/__mocks__/fixtures.ts
View file

@ -1,4 +1,8 @@
import { ArrowInfo, CardInfo, CounterInfo, PlayerProperties, ProtoInit } from 'types';
import { ProtoInit } from 'types';
import type { ServerInfo_Card } from 'generated/proto/serverinfo_card_pb';
import type { ServerInfo_Counter } from 'generated/proto/serverinfo_counter_pb';
import type { ServerInfo_Arrow } from 'generated/proto/serverinfo_arrow_pb';
import type { ServerInfo_PlayerProperties } from 'generated/proto/serverinfo_playerproperties_pb';
import { create } from '@bufbuild/protobuf';
import { ServerInfo_CardSchema } from 'generated/proto/serverinfo_card_pb';
import { ServerInfo_CounterSchema } from 'generated/proto/serverinfo_counter_pb';
@ -7,7 +11,7 @@ import { ServerInfo_ArrowSchema } from 'generated/proto/serverinfo_arrow_pb';
import { ServerInfo_PlayerPropertiesSchema } from 'generated/proto/serverinfo_playerproperties_pb';
import { GameEntry, GamesState, PlayerEntry, ZoneEntry } from '../game.interfaces';
export function makeCard(overrides: ProtoInit<CardInfo> = {}): CardInfo {
export function makeCard(overrides: ProtoInit<ServerInfo_Card> = {}): ServerInfo_Card {
return create(ServerInfo_CardSchema, {
id: 1,
name: 'Test Card',
@ -30,7 +34,7 @@ export function makeCard(overrides: ProtoInit<CardInfo> = {}): CardInfo {
});
}
export function makeCounter(overrides: ProtoInit<CounterInfo> = {}): CounterInfo {
export function makeCounter(overrides: ProtoInit<ServerInfo_Counter> = {}): ServerInfo_Counter {
return create(ServerInfo_CounterSchema, {
id: 1,
name: 'Life',
@ -41,7 +45,7 @@ export function makeCounter(overrides: ProtoInit<CounterInfo> = {}): CounterInfo
});
}
export function makeArrow(overrides: ProtoInit<ArrowInfo> = {}): ArrowInfo {
export function makeArrow(overrides: ProtoInit<ServerInfo_Arrow> = {}): ServerInfo_Arrow {
return create(ServerInfo_ArrowSchema, {
id: 1,
startPlayerId: 1,
@ -68,7 +72,7 @@ export function makeZoneEntry(overrides: Partial<ZoneEntry> = {}): ZoneEntry {
};
}
export function makePlayerProperties(overrides: ProtoInit<PlayerProperties> = {}): PlayerProperties {
export function makePlayerProperties(overrides: ProtoInit<ServerInfo_PlayerProperties> = {}): ServerInfo_PlayerProperties {
return create(ServerInfo_PlayerPropertiesSchema, {
playerId: 1,
spectator: false,

84
webclient/src/store/game/game.actions.ts
View file

@ -1,25 +1,23 @@
import {
AttachCardData,
ChangeZonePropertiesData,
CreateArrowData,
CreateCounterData,
CreateTokenData,
DelCounterData,
DeleteArrowData,
DestroyCardData,
DrawCardsData,
DumpZoneData,
FlipCardData,
GameStateChangedData,
MoveCardData,
PlayerProperties,
RevealCardsData,
RollDieData,
SetCardAttrData,
SetCardCounterData,
SetCounterData,
ShuffleData,
} from 'types';
import type { Event_AttachCard } from 'generated/proto/event_attach_card_pb';
import type { Event_ChangeZoneProperties } from 'generated/proto/event_change_zone_properties_pb';
import type { Event_CreateArrow } from 'generated/proto/event_create_arrow_pb';
import type { Event_CreateCounter } from 'generated/proto/event_create_counter_pb';
import type { Event_CreateToken } from 'generated/proto/event_create_token_pb';
import type { Event_DelCounter } from 'generated/proto/event_del_counter_pb';
import type { Event_DeleteArrow } from 'generated/proto/event_delete_arrow_pb';
import type { Event_DestroyCard } from 'generated/proto/event_destroy_card_pb';
import type { Event_DrawCards } from 'generated/proto/event_draw_cards_pb';
import type { Event_DumpZone } from 'generated/proto/event_dump_zone_pb';
import type { Event_FlipCard } from 'generated/proto/event_flip_card_pb';
import type { Event_GameStateChanged } from 'generated/proto/event_game_state_changed_pb';
import type { Event_MoveCard } from 'generated/proto/event_move_card_pb';
import type { ServerInfo_PlayerProperties } from 'generated/proto/serverinfo_playerproperties_pb';
import type { Event_RevealCards } from 'generated/proto/event_reveal_cards_pb';
import type { Event_RollDie } from 'generated/proto/event_roll_die_pb';
import type { Event_SetCardAttr } from 'generated/proto/event_set_card_attr_pb';
import type { Event_SetCardCounter } from 'generated/proto/event_set_card_counter_pb';
import type { Event_SetCounter } from 'generated/proto/event_set_counter_pb';
import type { Event_Shuffle } from 'generated/proto/event_shuffle_pb';
import { GameEntry } from './game.interfaces';
import { Types } from './game.types';
@ -50,13 +48,13 @@ export const Actions = {
hostId,
}),
gameStateChanged: (gameId: number, data: GameStateChangedData) => ({
gameStateChanged: (gameId: number, data: Event_GameStateChanged) => ({
type: Types.GAME_STATE_CHANGED,
gameId,
data,
}),
playerJoined: (gameId: number, playerProperties: PlayerProperties) => ({
playerJoined: (gameId: number, playerProperties: ServerInfo_PlayerProperties) => ({
type: Types.PLAYER_JOINED,
gameId,
playerProperties,
@ -69,7 +67,7 @@ export const Actions = {
reason,
}),
playerPropertiesChanged: (gameId: number, playerId: number, properties: PlayerProperties) => ({
playerPropertiesChanged: (gameId: number, playerId: number, properties: ServerInfo_PlayerProperties) => ({
type: Types.PLAYER_PROPERTIES_CHANGED,
gameId,
playerId,
@ -81,112 +79,112 @@ export const Actions = {
gameId,
}),
cardMoved: (gameId: number, playerId: number, data: MoveCardData) => ({
cardMoved: (gameId: number, playerId: number, data: Event_MoveCard) => ({
type: Types.CARD_MOVED,
gameId,
playerId,
data,
}),
cardFlipped: (gameId: number, playerId: number, data: FlipCardData) => ({
cardFlipped: (gameId: number, playerId: number, data: Event_FlipCard) => ({
type: Types.CARD_FLIPPED,
gameId,
playerId,
data,
}),
cardDestroyed: (gameId: number, playerId: number, data: DestroyCardData) => ({
cardDestroyed: (gameId: number, playerId: number, data: Event_DestroyCard) => ({
type: Types.CARD_DESTROYED,
gameId,
playerId,
data,
}),
cardAttached: (gameId: number, playerId: number, data: AttachCardData) => ({
cardAttached: (gameId: number, playerId: number, data: Event_AttachCard) => ({
type: Types.CARD_ATTACHED,
gameId,
playerId,
data,
}),
tokenCreated: (gameId: number, playerId: number, data: CreateTokenData) => ({
tokenCreated: (gameId: number, playerId: number, data: Event_CreateToken) => ({
type: Types.TOKEN_CREATED,
gameId,
playerId,
data,
}),
cardAttrChanged: (gameId: number, playerId: number, data: SetCardAttrData) => ({
cardAttrChanged: (gameId: number, playerId: number, data: Event_SetCardAttr) => ({
type: Types.CARD_ATTR_CHANGED,
gameId,
playerId,
data,
}),
cardCounterChanged: (gameId: number, playerId: number, data: SetCardCounterData) => ({
cardCounterChanged: (gameId: number, playerId: number, data: Event_SetCardCounter) => ({
type: Types.CARD_COUNTER_CHANGED,
gameId,
playerId,
data,
}),
arrowCreated: (gameId: number, playerId: number, data: CreateArrowData) => ({
arrowCreated: (gameId: number, playerId: number, data: Event_CreateArrow) => ({
type: Types.ARROW_CREATED,
gameId,
playerId,
data,
}),
arrowDeleted: (gameId: number, playerId: number, data: DeleteArrowData) => ({
arrowDeleted: (gameId: number, playerId: number, data: Event_DeleteArrow) => ({
type: Types.ARROW_DELETED,
gameId,
playerId,
data,
}),
counterCreated: (gameId: number, playerId: number, data: CreateCounterData) => ({
counterCreated: (gameId: number, playerId: number, data: Event_CreateCounter) => ({
type: Types.COUNTER_CREATED,
gameId,
playerId,
data,
}),
counterSet: (gameId: number, playerId: number, data: SetCounterData) => ({
counterSet: (gameId: number, playerId: number, data: Event_SetCounter) => ({
type: Types.COUNTER_SET,
gameId,
playerId,
data,
}),
counterDeleted: (gameId: number, playerId: number, data: DelCounterData) => ({
counterDeleted: (gameId: number, playerId: number, data: Event_DelCounter) => ({
type: Types.COUNTER_DELETED,
gameId,
playerId,
data,
}),
cardsDrawn: (gameId: number, playerId: number, data: DrawCardsData) => ({
cardsDrawn: (gameId: number, playerId: number, data: Event_DrawCards) => ({
type: Types.CARDS_DRAWN,
gameId,
playerId,
data,
}),
cardsRevealed: (gameId: number, playerId: number, data: RevealCardsData) => ({
cardsRevealed: (gameId: number, playerId: number, data: Event_RevealCards) => ({
type: Types.CARDS_REVEALED,
gameId,
playerId,
data,
}),
zoneShuffled: (gameId: number, playerId: number, data: ShuffleData) => ({
zoneShuffled: (gameId: number, playerId: number, data: Event_Shuffle) => ({
type: Types.ZONE_SHUFFLED,
gameId,
playerId,
data,
}),
dieRolled: (gameId: number, playerId: number, data: RollDieData) => ({
dieRolled: (gameId: number, playerId: number, data: Event_RollDie) => ({
type: Types.DIE_ROLLED,
gameId,
playerId,
@ -211,14 +209,14 @@ export const Actions = {
reversed,
}),
zoneDumped: (gameId: number, playerId: number, data: DumpZoneData) => ({
zoneDumped: (gameId: number, playerId: number, data: Event_DumpZone) => ({
type: Types.ZONE_DUMPED,
gameId,
playerId,
data,
}),
zonePropertiesChanged: (gameId: number, playerId: number, data: ChangeZonePropertiesData) => ({
zonePropertiesChanged: (gameId: number, playerId: number, data: Event_ChangeZoneProperties) => ({
type: Types.ZONE_PROPERTIES_CHANGED,
gameId,
playerId,

84
webclient/src/store/game/game.dispatch.ts
View file

@ -1,25 +1,23 @@
import {
AttachCardData,
ChangeZonePropertiesData,
CreateArrowData,
CreateCounterData,
CreateTokenData,
DelCounterData,
DeleteArrowData,
DestroyCardData,
DrawCardsData,
DumpZoneData,
FlipCardData,
GameStateChangedData,
MoveCardData,
PlayerProperties,
RevealCardsData,
RollDieData,
SetCardAttrData,
SetCardCounterData,
SetCounterData,
ShuffleData,
} from 'types';
import type { Event_AttachCard } from 'generated/proto/event_attach_card_pb';
import type { Event_ChangeZoneProperties } from 'generated/proto/event_change_zone_properties_pb';
import type { Event_CreateArrow } from 'generated/proto/event_create_arrow_pb';
import type { Event_CreateCounter } from 'generated/proto/event_create_counter_pb';
import type { Event_CreateToken } from 'generated/proto/event_create_token_pb';
import type { Event_DelCounter } from 'generated/proto/event_del_counter_pb';
import type { Event_DeleteArrow } from 'generated/proto/event_delete_arrow_pb';
import type { Event_DestroyCard } from 'generated/proto/event_destroy_card_pb';
import type { Event_DrawCards } from 'generated/proto/event_draw_cards_pb';
import type { Event_DumpZone } from 'generated/proto/event_dump_zone_pb';
import type { Event_FlipCard } from 'generated/proto/event_flip_card_pb';
import type { Event_GameStateChanged } from 'generated/proto/event_game_state_changed_pb';
import type { Event_MoveCard } from 'generated/proto/event_move_card_pb';
import type { ServerInfo_PlayerProperties } from 'generated/proto/serverinfo_playerproperties_pb';
import type { Event_RevealCards } from 'generated/proto/event_reveal_cards_pb';
import type { Event_RollDie } from 'generated/proto/event_roll_die_pb';
import type { Event_SetCardAttr } from 'generated/proto/event_set_card_attr_pb';
import type { Event_SetCardCounter } from 'generated/proto/event_set_card_counter_pb';
import type { Event_SetCounter } from 'generated/proto/event_set_counter_pb';
import type { Event_Shuffle } from 'generated/proto/event_shuffle_pb';
import { store } from 'store/store';
import { Actions } from './game.actions';
import { GameEntry } from './game.interfaces';
@ -45,11 +43,11 @@ export const Dispatch = {
store.dispatch(Actions.gameHostChanged(gameId, hostId));
},
gameStateChanged: (gameId: number, data: GameStateChangedData) => {
gameStateChanged: (gameId: number, data: Event_GameStateChanged) => {
store.dispatch(Actions.gameStateChanged(gameId, data));
},
playerJoined: (gameId: number, playerProperties: PlayerProperties) => {
playerJoined: (gameId: number, playerProperties: ServerInfo_PlayerProperties) => {
store.dispatch(Actions.playerJoined(gameId, playerProperties));
},
@ -57,7 +55,7 @@ export const Dispatch = {
store.dispatch(Actions.playerLeft(gameId, playerId, reason));
},
playerPropertiesChanged: (gameId: number, playerId: number, properties: PlayerProperties) => {
playerPropertiesChanged: (gameId: number, playerId: number, properties: ServerInfo_PlayerProperties) => {
store.dispatch(Actions.playerPropertiesChanged(gameId, playerId, properties));
},
@ -65,67 +63,67 @@ export const Dispatch = {
store.dispatch(Actions.kicked(gameId));
},
cardMoved: (gameId: number, playerId: number, data: MoveCardData) => {
cardMoved: (gameId: number, playerId: number, data: Event_MoveCard) => {
store.dispatch(Actions.cardMoved(gameId, playerId, data));
},
cardFlipped: (gameId: number, playerId: number, data: FlipCardData) => {
cardFlipped: (gameId: number, playerId: number, data: Event_FlipCard) => {
store.dispatch(Actions.cardFlipped(gameId, playerId, data));
},
cardDestroyed: (gameId: number, playerId: number, data: DestroyCardData) => {
cardDestroyed: (gameId: number, playerId: number, data: Event_DestroyCard) => {
store.dispatch(Actions.cardDestroyed(gameId, playerId, data));
},
cardAttached: (gameId: number, playerId: number, data: AttachCardData) => {
cardAttached: (gameId: number, playerId: number, data: Event_AttachCard) => {
store.dispatch(Actions.cardAttached(gameId, playerId, data));
},
tokenCreated: (gameId: number, playerId: number, data: CreateTokenData) => {
tokenCreated: (gameId: number, playerId: number, data: Event_CreateToken) => {
store.dispatch(Actions.tokenCreated(gameId, playerId, data));
},
cardAttrChanged: (gameId: number, playerId: number, data: SetCardAttrData) => {
cardAttrChanged: (gameId: number, playerId: number, data: Event_SetCardAttr) => {
store.dispatch(Actions.cardAttrChanged(gameId, playerId, data));
},
cardCounterChanged: (gameId: number, playerId: number, data: SetCardCounterData) => {
cardCounterChanged: (gameId: number, playerId: number, data: Event_SetCardCounter) => {
store.dispatch(Actions.cardCounterChanged(gameId, playerId, data));
},
arrowCreated: (gameId: number, playerId: number, data: CreateArrowData) => {
arrowCreated: (gameId: number, playerId: number, data: Event_CreateArrow) => {
store.dispatch(Actions.arrowCreated(gameId, playerId, data));
},
arrowDeleted: (gameId: number, playerId: number, data: DeleteArrowData) => {
arrowDeleted: (gameId: number, playerId: number, data: Event_DeleteArrow) => {
store.dispatch(Actions.arrowDeleted(gameId, playerId, data));
},
counterCreated: (gameId: number, playerId: number, data: CreateCounterData) => {
counterCreated: (gameId: number, playerId: number, data: Event_CreateCounter) => {
store.dispatch(Actions.counterCreated(gameId, playerId, data));
},
counterSet: (gameId: number, playerId: number, data: SetCounterData) => {
counterSet: (gameId: number, playerId: number, data: Event_SetCounter) => {
store.dispatch(Actions.counterSet(gameId, playerId, data));
},
counterDeleted: (gameId: number, playerId: number, data: DelCounterData) => {
counterDeleted: (gameId: number, playerId: number, data: Event_DelCounter) => {
store.dispatch(Actions.counterDeleted(gameId, playerId, data));
},
cardsDrawn: (gameId: number, playerId: number, data: DrawCardsData) => {
cardsDrawn: (gameId: number, playerId: number, data: Event_DrawCards) => {
store.dispatch(Actions.cardsDrawn(gameId, playerId, data));
},
cardsRevealed: (gameId: number, playerId: number, data: RevealCardsData) => {
cardsRevealed: (gameId: number, playerId: number, data: Event_RevealCards) => {
store.dispatch(Actions.cardsRevealed(gameId, playerId, data));
},
zoneShuffled: (gameId: number, playerId: number, data: ShuffleData) => {
zoneShuffled: (gameId: number, playerId: number, data: Event_Shuffle) => {
store.dispatch(Actions.zoneShuffled(gameId, playerId, data));
},
dieRolled: (gameId: number, playerId: number, data: RollDieData) => {
dieRolled: (gameId: number, playerId: number, data: Event_RollDie) => {
store.dispatch(Actions.dieRolled(gameId, playerId, data));
},
@ -141,11 +139,11 @@ export const Dispatch = {
store.dispatch(Actions.turnReversed(gameId, reversed));
},
zoneDumped: (gameId: number, playerId: number, data: DumpZoneData) => {
zoneDumped: (gameId: number, playerId: number, data: Event_DumpZone) => {
store.dispatch(Actions.zoneDumped(gameId, playerId, data));
},
zonePropertiesChanged: (gameId: number, playerId: number, data: ChangeZonePropertiesData) => {
zonePropertiesChanged: (gameId: number, playerId: number, data: Event_ChangeZoneProperties) => {
store.dispatch(Actions.zonePropertiesChanged(gameId, playerId, data));
},

13
webclient/src/store/game/game.interfaces.ts
View file

@ -1,4 +1,7 @@
import { ArrowInfo, CardInfo, CounterInfo, PlayerProperties } from 'types';
import type { ServerInfo_Card } from 'generated/proto/serverinfo_card_pb';
import type { ServerInfo_Counter } from 'generated/proto/serverinfo_counter_pb';
import type { ServerInfo_Arrow } from 'generated/proto/serverinfo_arrow_pb';
import type { ServerInfo_PlayerProperties } from 'generated/proto/serverinfo_playerproperties_pb';
export interface GamesState {
games: { [gameId: number]: GameEntry };
@ -29,14 +32,14 @@ export interface GameEntry {
/** Normalized from ServerInfo_Player — keyed collections for O(1) lookup. */
export interface PlayerEntry {
properties: PlayerProperties;
properties: ServerInfo_PlayerProperties;
deckList: string;
/** Zones keyed by zone name (e.g. "hand", "deck", "table"). */
zones: { [zoneName: string]: ZoneEntry };
/** Player-level counters (e.g. life) keyed by counter id. */
counters: { [counterId: number]: CounterInfo };
counters: { [counterId: number]: ServerInfo_Counter };
/** Arrows keyed by arrow id. */
arrows: { [arrowId: number]: ArrowInfo };
arrows: { [arrowId: number]: ServerInfo_Arrow };
}
/** Normalized from ServerInfo_Zone — card list is an ordered array matching proto. */
@ -48,7 +51,7 @@ export interface ZoneEntry {
/** Authoritative card count (used for hidden zones where cardList may be empty). */
cardCount: number;
/** Ordered card list; may be empty for hidden zones with no dump active. */
cards: CardInfo[];
cards: ServerInfo_Card[];
alwaysRevealTopCard: boolean;
alwaysLookAtTopCard: boolean;
}

5
webclient/src/store/game/game.reducer.spec.ts
View file

@ -1,5 +1,6 @@
import { create } from '@bufbuild/protobuf';
import { CardAttribute, PlayerInfo } from 'types';
import { CardAttribute } from 'generated/proto/card_attributes_pb';
import type { ServerInfo_Player } from 'generated/proto/serverinfo_player_pb';
import { gamesReducer } from './game.reducer';
import { Types } from './game.types';
import {
@ -68,7 +69,7 @@ describe('2B: Game state & player management', () => {
const card = makeCard({ id: 5 });
const counter = makeCounter({ id: 2 });
const arrow = makeArrow({ id: 3 });
const playerList: PlayerInfo[] = [
const playerList: ServerInfo_Player[] = [
create(ServerInfo_PlayerSchema, {
properties: makePlayerProperties({ playerId: 7 }),
deckList: 'some deck',

37
webclient/src/store/game/game.reducer.ts
View file

@ -1,12 +1,9 @@
import {
ArrowInfo,
CardAttribute,
CardCounterInfo,
CardInfo,
CounterInfo,
PlayerInfo,
PlayerProperties,
} from 'types';
import { CardAttribute } from 'generated/proto/card_attributes_pb';
import type { ServerInfo_CardCounter } from 'generated/proto/serverinfo_cardcounter_pb';
import type { ServerInfo_Card } from 'generated/proto/serverinfo_card_pb';
import type { ServerInfo_Counter } from 'generated/proto/serverinfo_counter_pb';
import type { ServerInfo_Arrow } from 'generated/proto/serverinfo_arrow_pb';
import type { ServerInfo_Player } from 'generated/proto/serverinfo_player_pb';
import { create } from '@bufbuild/protobuf';
import { ServerInfo_CardSchema } from 'generated/proto/serverinfo_card_pb';
import { ServerInfo_CardCounterSchema } from 'generated/proto/serverinfo_cardcounter_pb';
@ -77,7 +74,7 @@ function removeGame(state: GamesState, gameId: number): GamesState {
}
/** Converts the proto PlayerInfo[] array into the keyed PlayerEntry map used in the store. */
function normalizePlayers(playerList: PlayerInfo[]): { [playerId: number]: PlayerEntry } {
function normalizePlayers(playerList: ServerInfo_Player[]): { [playerId: number]: PlayerEntry } {
const players: { [playerId: number]: PlayerEntry } = {};
for (const player of playerList) {
const playerId = player.properties.playerId;
@ -95,12 +92,12 @@ function normalizePlayers(playerList: PlayerInfo[]): { [playerId: number]: Playe
};
}
const counters: { [counterId: number]: CounterInfo } = {};
const counters: { [counterId: number]: ServerInfo_Counter } = {};
for (const counter of player.counterList) {
counters[counter.id] = counter;
}
const arrows: { [arrowId: number]: ArrowInfo } = {};
const arrows: { [arrowId: number]: ServerInfo_Arrow } = {};
for (const arrow of player.arrowList) {
arrows[arrow.id] = arrow;
}
@ -123,7 +120,7 @@ function buildEmptyCard(
y: number,
faceDown: boolean,
providerId: string
): CardInfo {
): ServerInfo_Card {
return create(ServerInfo_CardSchema, {
id,
name,
@ -209,7 +206,7 @@ export const gamesReducer = (state: GamesState = initialState, action: GameActio
return state;
}
const newPlayer: PlayerEntry = {
properties: playerProperties as PlayerProperties,
properties: playerProperties,
deckList: '',
zones: {},
counters: {},
@ -269,8 +266,8 @@ export const gamesReducer = (state: GamesState = initialState, action: GameActio
}
// Locate card in source zone (by id for visible zones, by position for hidden)
let removedCard: CardInfo | undefined;
let newSourceCards: CardInfo[];
let removedCard: ServerInfo_Card | undefined;
let newSourceCards: ServerInfo_Card[];
if (cardId >= 0) {
removedCard = sourceZoneEntry.cards.find(c => c.id === cardId);
newSourceCards = sourceZoneEntry.cards.filter(c => c.id !== cardId);
@ -283,7 +280,7 @@ export const gamesReducer = (state: GamesState = initialState, action: GameActio
}
const effectiveNewId = newCardId >= 0 ? newCardId : (removedCard?.id ?? -1);
const movedCard: CardInfo = removedCard
const movedCard: ServerInfo_Card = removedCard
? {
...removedCard,
id: effectiveNewId,
@ -426,7 +423,7 @@ export const gamesReducer = (state: GamesState = initialState, action: GameActio
return state;
}
const newCard: CardInfo = create(ServerInfo_CardSchema, {
const newCard: ServerInfo_Card = create(ServerInfo_CardSchema, {
id: cardId,
name: cardName,
x,
@ -472,7 +469,7 @@ export const gamesReducer = (state: GamesState = initialState, action: GameActio
return state;
}
const attrPatch: Partial<CardInfo> = {};
const attrPatch: Partial<ServerInfo_Card> = {};
switch (attribute as CardAttribute) {
case CardAttribute.AttrTapped: attrPatch.tapped = attrValue === '1'; break;
case CardAttribute.AttrAttacking: attrPatch.attacking = attrValue === '1'; break;
@ -510,7 +507,7 @@ export const gamesReducer = (state: GamesState = initialState, action: GameActio
}
const card = zone.cards[cardIdx];
let newCounterList: CardCounterInfo[];
let newCounterList: ServerInfo_CardCounter[];
if (counterValue <= 0) {
newCounterList = card.counterList.filter(c => c.id !== counterId);
} else {

4
webclient/src/store/game/game.selectors.ts
View file

@ -1,12 +1,12 @@
import { createSelector } from '@reduxjs/toolkit';
import { CardInfo } from 'types';
import type { ServerInfo_Card } from 'generated/proto/serverinfo_card_pb';
import { GamesState, GameEntry, PlayerEntry, ZoneEntry } from './game.interfaces';
interface State {
games: GamesState;
}
const EMPTY_ARRAY: CardInfo[] = [];
const EMPTY_ARRAY: ServerInfo_Card[] = [];
const EMPTY_OBJECT = {} as Record<string, never>;
export const Selectors = {

4
webclient/src/store/rooms/__mocks__/rooms-fixtures.ts
View file

@ -5,16 +5,16 @@ import {
ProtoInit,
Room,
SortDirection,
User,
UserSortField,
} from 'types';
import type { ServerInfo_User } from 'generated/proto/serverinfo_user_pb';
import { create } from '@bufbuild/protobuf';
import { ServerInfo_UserSchema } from 'generated/proto/serverinfo_user_pb';
import { ServerInfo_GameSchema } from 'generated/proto/serverinfo_game_pb';
import { ServerInfo_RoomSchema } from 'generated/proto/serverinfo_room_pb';
import { RoomsState } from '../rooms.interfaces';
export function makeUser(overrides: ProtoInit<User> = {}): User {
export function makeUser(overrides: ProtoInit<ServerInfo_User> = {}): ServerInfo_User {
return create(ServerInfo_UserSchema, {
name: 'TestUser',
accountageSecs: 0n,

5
webclient/src/store/rooms/rooms.actions.tsx
View file

@ -1,4 +1,5 @@
import { GameSortField, Message, SortDirection, User } from 'types';
import { GameSortField, Message, SortDirection } from 'types';
import type { ServerInfo_User } from 'generated/proto/serverinfo_user_pb';
import type { ServerInfo_Room } from 'generated/proto/serverinfo_room_pb';
import type { ServerInfo_Game } from 'generated/proto/serverinfo_game_pb';
@ -36,7 +37,7 @@ export const Actions = {
games,
}),
userJoined: (roomId: number, user: User) => ({
userJoined: (roomId: number, user: ServerInfo_User) => ({
type: Types.USER_JOINED,
roomId,
user,

5
webclient/src/store/rooms/rooms.dispatch.tsx
View file

@ -1,4 +1,5 @@
import { GameSortField, Message, SortDirection, User } from 'types';
import { GameSortField, Message, SortDirection } from 'types';
import type { ServerInfo_User } from 'generated/proto/serverinfo_user_pb';
import type { ServerInfo_Room } from 'generated/proto/serverinfo_room_pb';
import type { ServerInfo_Game } from 'generated/proto/serverinfo_game_pb';
@ -31,7 +32,7 @@ export const Dispatch = {
store.dispatch(Actions.updateGames(roomId, games));
},
userJoined: (roomId: number, user: User) => {
userJoined: (roomId: number, user: ServerInfo_User) => {
store.dispatch(Actions.userJoined(roomId, user));
},

32
webclient/src/store/server/__mocks__/server-fixtures.ts
View file

@ -1,19 +1,19 @@
import {
BanHistoryItem,
DeckList,
DeckStorageTreeItem,
Game,
LogItem,
ProtoInit,
ReplayMatch,
SortDirection,
StatusEnum,
User,
UserSortField,
WebSocketConnectOptions,
WarnHistoryItem,
WarnListItem,
} from 'types';
import type { ServerInfo_User } from 'generated/proto/serverinfo_user_pb';
import type { ServerInfo_Ban } from 'generated/proto/serverinfo_ban_pb';
import type { ServerInfo_Warning } from 'generated/proto/serverinfo_warning_pb';
import type { Response_WarnList } from 'generated/proto/response_warn_list_pb';
import type { ServerInfo_ReplayMatch } from 'generated/proto/serverinfo_replay_match_pb';
import type { ServerInfo_ChatMessage } from 'generated/proto/serverinfo_chat_message_pb';
import type { Response_DeckList } from 'generated/proto/response_deck_list_pb';
import type { ServerInfo_DeckStorage_TreeItem } from 'generated/proto/serverinfo_deckstorage_pb';
import { create } from '@bufbuild/protobuf';
import { ServerInfo_GameSchema } from 'generated/proto/serverinfo_game_pb';
import { ServerInfo_UserSchema } from 'generated/proto/serverinfo_user_pb';
@ -26,7 +26,7 @@ import { ServerInfo_DeckStorage_TreeItemSchema, ServerInfo_DeckStorage_FolderSch
import { Response_DeckListSchema } from 'generated/proto/response_deck_list_pb';
import { ServerState } from '../server.interfaces';
export function makeUser(overrides: ProtoInit<User> = {}): User {
export function makeUser(overrides: ProtoInit<ServerInfo_User> = {}): ServerInfo_User {
return create(ServerInfo_UserSchema, {
name: 'TestUser',
accountageSecs: 0n,
@ -36,7 +36,7 @@ export function makeUser(overrides: ProtoInit<User> = {}): User {
});
}
export function makeLogItem(overrides: ProtoInit<LogItem> = {}): LogItem {
export function makeLogItem(overrides: ProtoInit<ServerInfo_ChatMessage> = {}): ServerInfo_ChatMessage {
return create(ServerInfo_ChatMessageSchema, {
message: '',
senderId: '',
@ -50,7 +50,7 @@ export function makeLogItem(overrides: ProtoInit<LogItem> = {}): LogItem {
});
}
export function makeBanHistoryItem(overrides: ProtoInit<BanHistoryItem> = {}): BanHistoryItem {
export function makeBanHistoryItem(overrides: ProtoInit<ServerInfo_Ban> = {}): ServerInfo_Ban {
return create(ServerInfo_BanSchema, {
adminId: '',
adminName: '',
@ -62,7 +62,7 @@ export function makeBanHistoryItem(overrides: ProtoInit<BanHistoryItem> = {}): B
});
}
export function makeWarnHistoryItem(overrides: ProtoInit<WarnHistoryItem> = {}): WarnHistoryItem {
export function makeWarnHistoryItem(overrides: ProtoInit<ServerInfo_Warning> = {}): ServerInfo_Warning {
return create(ServerInfo_WarningSchema, {
userName: '',
adminName: '',
@ -72,7 +72,7 @@ export function makeWarnHistoryItem(overrides: ProtoInit<WarnHistoryItem> = {}):
});
}
export function makeWarnListItem(overrides: ProtoInit<WarnListItem> = {}): WarnListItem {
export function makeWarnListItem(overrides: ProtoInit<Response_WarnList> = {}): Response_WarnList {
return create(Response_WarnListSchema, {
warning: [],
userName: '',
@ -81,7 +81,7 @@ export function makeWarnListItem(overrides: ProtoInit<WarnListItem> = {}): WarnL
});
}
export function makeDeckTreeItem(overrides: ProtoInit<DeckStorageTreeItem> = {}): DeckStorageTreeItem {
export function makeDeckTreeItem(overrides: ProtoInit<ServerInfo_DeckStorage_TreeItem> = {}): ServerInfo_DeckStorage_TreeItem {
return create(ServerInfo_DeckStorage_TreeItemSchema, {
id: 1,
name: 'item',
@ -89,14 +89,14 @@ export function makeDeckTreeItem(overrides: ProtoInit<DeckStorageTreeItem> = {})
});
}
export function makeDeckList(overrides: ProtoInit<DeckList> = {}): DeckList {
export function makeDeckList(overrides: ProtoInit<Response_DeckList> = {}): Response_DeckList {
return create(Response_DeckListSchema, {
root: create(ServerInfo_DeckStorage_FolderSchema, { items: [] }),
...overrides,
});
}
export function makeReplayMatch(overrides: ProtoInit<ReplayMatch> = {}): ReplayMatch {
export function makeReplayMatch(overrides: ProtoInit<ServerInfo_ReplayMatch> = {}): ServerInfo_ReplayMatch {
return create(ServerInfo_ReplayMatchSchema, {
gameId: 1,
roomName: 'Test Room',

47
webclient/src/store/server/server.actions.ts
View file

@ -1,7 +1,14 @@
import {
BanHistoryItem, DeckList, DeckStorageTreeItem, GametypeMap, LogItem, ReplayMatch,
User, WebSocketConnectOptions, WarnHistoryItem, WarnListItem
GametypeMap, WebSocketConnectOptions
} from 'types';
import type { ServerInfo_User } from 'generated/proto/serverinfo_user_pb';
import type { ServerInfo_Ban } from 'generated/proto/serverinfo_ban_pb';
import type { ServerInfo_Warning } from 'generated/proto/serverinfo_warning_pb';
import type { Response_WarnList } from 'generated/proto/response_warn_list_pb';
import type { ServerInfo_ReplayMatch } from 'generated/proto/serverinfo_replay_match_pb';
import type { Response_DeckList } from 'generated/proto/response_deck_list_pb';
import type { ServerInfo_DeckStorage_TreeItem } from 'generated/proto/serverinfo_deckstorage_pb';
import type { ServerInfo_ChatMessage } from 'generated/proto/serverinfo_chat_message_pb';
import type { ServerInfo_Game } from 'generated/proto/serverinfo_game_pb';
import { NotifyUserData, ServerShutdownData, UserMessageData } from 'websocket/events/session/interfaces';
import { ServerStateStatus } from './server.interfaces';
@ -41,11 +48,11 @@ export const Actions = {
type: Types.SERVER_MESSAGE,
message
}),
updateBuddyList: (buddyList: User[]) => ({
updateBuddyList: (buddyList: ServerInfo_User[]) => ({
type: Types.UPDATE_BUDDY_LIST,
buddyList
}),
addToBuddyList: (user: User) => ({
addToBuddyList: (user: ServerInfo_User) => ({
type: Types.ADD_TO_BUDDY_LIST,
user
}),
@ -53,11 +60,11 @@ export const Actions = {
type: Types.REMOVE_FROM_BUDDY_LIST,
userName
}),
updateIgnoreList: (ignoreList: User[]) => ({
updateIgnoreList: (ignoreList: ServerInfo_User[]) => ({
type: Types.UPDATE_IGNORE_LIST,
ignoreList
}),
addToIgnoreList: (user: User) => ({
addToIgnoreList: (user: ServerInfo_User) => ({
type: Types.ADD_TO_IGNORE_LIST,
user
}),
@ -73,15 +80,15 @@ export const Actions = {
type: Types.UPDATE_STATUS,
status
}),
updateUser: (user: User) => ({
updateUser: (user: ServerInfo_User) => ({
type: Types.UPDATE_USER,
user
}),
updateUsers: (users: User[]) => ({
updateUsers: (users: ServerInfo_User[]) => ({
type: Types.UPDATE_USERS,
users
}),
userJoined: (user: User) => ({
userJoined: (user: ServerInfo_User) => ({
type: Types.USER_JOINED,
user
}),
@ -89,7 +96,7 @@ export const Actions = {
type: Types.USER_LEFT,
name
}),
viewLogs: (logs: LogItem[]) => ({
viewLogs: (logs: ServerInfo_ChatMessage[]) => ({
type: Types.VIEW_LOGS,
logs
}),
@ -162,15 +169,15 @@ export const Actions = {
accountPasswordChange: () => ({
type: Types.ACCOUNT_PASSWORD_CHANGE,
}),
accountEditChanged: (user: Partial<User>) => ({
accountEditChanged: (user: Partial<ServerInfo_User>) => ({
type: Types.ACCOUNT_EDIT_CHANGED,
user,
}),
accountImageChanged: (user: Partial<User>) => ({
accountImageChanged: (user: Partial<ServerInfo_User>) => ({
type: Types.ACCOUNT_IMAGE_CHANGED,
user,
}),
getUserInfo: (userInfo: User) => ({
getUserInfo: (userInfo: ServerInfo_User) => ({
type: Types.GET_USER_INFO,
userInfo,
}),
@ -200,17 +207,17 @@ export const Actions = {
type: Types.BAN_FROM_SERVER,
userName,
}),
banHistory: (userName: string, banHistory: BanHistoryItem[]) => ({
banHistory: (userName: string, banHistory: ServerInfo_Ban[]) => ({
type: Types.BAN_HISTORY,
userName,
banHistory,
}),
warnHistory: (userName: string, warnHistory: WarnHistoryItem[]) => ({
warnHistory: (userName: string, warnHistory: ServerInfo_Warning[]) => ({
type: Types.WARN_HISTORY,
userName,
warnHistory,
}),
warnListOptions: (warnList: WarnListItem[]) => ({
warnListOptions: (warnList: Response_WarnList[]) => ({
type: Types.WARN_LIST_OPTIONS,
warnList,
}),
@ -238,14 +245,14 @@ export const Actions = {
userName,
notes,
}),
replayList: (matchList: ReplayMatch[]) => ({ type: Types.REPLAY_LIST, matchList }),
replayAdded: (matchInfo: ReplayMatch) => ({ type: Types.REPLAY_ADDED, matchInfo }),
replayList: (matchList: ServerInfo_ReplayMatch[]) => ({ type: Types.REPLAY_LIST, matchList }),
replayAdded: (matchInfo: ServerInfo_ReplayMatch) => ({ type: Types.REPLAY_ADDED, matchInfo }),
replayModifyMatch: (gameId: number, doNotHide: boolean) => ({ type: Types.REPLAY_MODIFY_MATCH, gameId, doNotHide }),
replayDeleteMatch: (gameId: number) => ({ type: Types.REPLAY_DELETE_MATCH, gameId }),
backendDecks: (deckList: DeckList) => ({ type: Types.BACKEND_DECKS, deckList }),
backendDecks: (deckList: Response_DeckList) => ({ type: Types.BACKEND_DECKS, deckList }),
deckNewDir: (path: string, dirName: string) => ({ type: Types.DECK_NEW_DIR, path, dirName }),
deckDelDir: (path: string) => ({ type: Types.DECK_DEL_DIR, path }),
deckUpload: (path: string, treeItem: DeckStorageTreeItem) => ({ type: Types.DECK_UPLOAD, path, treeItem }),
deckUpload: (path: string, treeItem: ServerInfo_DeckStorage_TreeItem) => ({ type: Types.DECK_UPLOAD, path, treeItem }),
deckDelete: (deckId: number) => ({ type: Types.DECK_DELETE, deckId }),
gamesOfUser: (userName: string, games: ServerInfo_Game[], gametypeMap: GametypeMap) =>
({ type: Types.GAMES_OF_USER, userName, games, gametypeMap }),

47
webclient/src/store/server/server.dispatch.ts
View file

@ -1,9 +1,16 @@
import { Actions } from './server.actions';
import { store } from 'store';
import {
BanHistoryItem, DeckList, DeckStorageTreeItem, GametypeMap, LogItem, ReplayMatch,
User, WarnHistoryItem, WarnListItem, WebSocketConnectOptions
GametypeMap, WebSocketConnectOptions
} from 'types';
import type { ServerInfo_User } from 'generated/proto/serverinfo_user_pb';
import type { ServerInfo_Ban } from 'generated/proto/serverinfo_ban_pb';
import type { ServerInfo_Warning } from 'generated/proto/serverinfo_warning_pb';
import type { Response_WarnList } from 'generated/proto/response_warn_list_pb';
import type { ServerInfo_ReplayMatch } from 'generated/proto/serverinfo_replay_match_pb';
import type { Response_DeckList } from 'generated/proto/response_deck_list_pb';
import type { ServerInfo_DeckStorage_TreeItem } from 'generated/proto/serverinfo_deckstorage_pb';
import type { ServerInfo_ChatMessage } from 'generated/proto/serverinfo_chat_message_pb';
import type { ServerInfo_Game } from 'generated/proto/serverinfo_game_pb';
import { NotifyUserData, ServerShutdownData, UserMessageData } from 'websocket/events/session/interfaces';
@ -35,19 +42,19 @@ export const Dispatch = {
testConnectionFailed: () => {
store.dispatch(Actions.testConnectionFailed());
},
updateBuddyList: (buddyList: User[]) => {
updateBuddyList: (buddyList: ServerInfo_User[]) => {
store.dispatch(Actions.updateBuddyList(buddyList));
},
addToBuddyList: (user: User) => {
addToBuddyList: (user: ServerInfo_User) => {
store.dispatch(Actions.addToBuddyList(user));
},
removeFromBuddyList: (userName: string) => {
store.dispatch(Actions.removeFromBuddyList(userName));
},
updateIgnoreList: (ignoreList: User[]) => {
updateIgnoreList: (ignoreList: ServerInfo_User[]) => {
store.dispatch(Actions.updateIgnoreList(ignoreList));
},
addToIgnoreList: (user: User) => {
addToIgnoreList: (user: ServerInfo_User) => {
store.dispatch(Actions.addToIgnoreList(user));
},
removeFromIgnoreList: (userName: string) => {
@ -65,19 +72,19 @@ export const Dispatch = {
description
}));
},
updateUser: (user: User) => {
updateUser: (user: ServerInfo_User) => {
store.dispatch(Actions.updateUser(user));
},
updateUsers: (users: User[]) => {
updateUsers: (users: ServerInfo_User[]) => {
store.dispatch(Actions.updateUsers(users));
},
userJoined: (user: User) => {
userJoined: (user: ServerInfo_User) => {
store.dispatch(Actions.userJoined(user));
},
userLeft: (name: string) => {
store.dispatch(Actions.userLeft(name));
},
viewLogs: (logs: LogItem[]) => {
viewLogs: (logs: ServerInfo_ChatMessage[]) => {
store.dispatch(Actions.viewLogs(logs));
},
clearLogs: () => {
@ -143,13 +150,13 @@ export const Dispatch = {
accountPasswordChange: () => {
store.dispatch(Actions.accountPasswordChange());
},
accountEditChanged: (user: Partial<User>) => {
accountEditChanged: (user: Partial<ServerInfo_User>) => {
store.dispatch(Actions.accountEditChanged(user));
},
accountImageChanged: (user: Partial<User>) => {
accountImageChanged: (user: Partial<ServerInfo_User>) => {
store.dispatch(Actions.accountImageChanged(user));
},
getUserInfo: (userInfo: User) => {
getUserInfo: (userInfo: ServerInfo_User) => {
store.dispatch(Actions.getUserInfo(userInfo));
},
notifyUser: (notification: NotifyUserData) => {
@ -170,13 +177,13 @@ export const Dispatch = {
banFromServer: (userName: string) => {
store.dispatch(Actions.banFromServer(userName));
},
banHistory: (userName: string, banHistory: BanHistoryItem[]) => {
banHistory: (userName: string, banHistory: ServerInfo_Ban[]) => {
store.dispatch(Actions.banHistory(userName, banHistory))
},
warnHistory: (userName: string, warnHistory: WarnHistoryItem[]) => {
warnHistory: (userName: string, warnHistory: ServerInfo_Warning[]) => {
store.dispatch(Actions.warnHistory(userName, warnHistory))
},
warnListOptions: (warnList: WarnListItem[]) => {
warnListOptions: (warnList: Response_WarnList[]) => {
store.dispatch(Actions.warnListOptions(warnList))
},
warnUser: (userName: string) => {
@ -194,10 +201,10 @@ export const Dispatch = {
updateAdminNotes: (userName: string, notes: string) => {
store.dispatch(Actions.updateAdminNotes(userName, notes));
},
replayList: (matchList: ReplayMatch[]) => {
replayList: (matchList: ServerInfo_ReplayMatch[]) => {
store.dispatch(Actions.replayList(matchList));
},
replayAdded: (matchInfo: ReplayMatch) => {
replayAdded: (matchInfo: ServerInfo_ReplayMatch) => {
store.dispatch(Actions.replayAdded(matchInfo));
},
replayModifyMatch: (gameId: number, doNotHide: boolean) => {
@ -206,7 +213,7 @@ export const Dispatch = {
replayDeleteMatch: (gameId: number) => {
store.dispatch(Actions.replayDeleteMatch(gameId));
},
backendDecks: (deckList: DeckList) => {
backendDecks: (deckList: Response_DeckList) => {
store.dispatch(Actions.backendDecks(deckList));
},
deckNewDir: (path: string, dirName: string) => {
@ -215,7 +222,7 @@ export const Dispatch = {
deckDelDir: (path: string) => {
store.dispatch(Actions.deckDelDir(path));
},
deckUpload: (path: string, treeItem: DeckStorageTreeItem) => {
deckUpload: (path: string, treeItem: ServerInfo_DeckStorage_TreeItem) => {
store.dispatch(Actions.deckUpload(path, treeItem));
},
deckDelete: (deckId: number) => {

35
webclient/src/store/server/server.interfaces.ts
View file

@ -1,6 +1,13 @@
import {
WarnHistoryItem, BanHistoryItem, DeckList, Game, LogItem, ReplayMatch, SortBy, User, UserSortField, WarnListItem
Game, SortBy, UserSortField
} from 'types';
import type { ServerInfo_User } from 'generated/proto/serverinfo_user_pb';
import type { ServerInfo_Ban } from 'generated/proto/serverinfo_ban_pb';
import type { ServerInfo_Warning } from 'generated/proto/serverinfo_warning_pb';
import type { Response_WarnList } from 'generated/proto/response_warn_list_pb';
import type { ServerInfo_ReplayMatch } from 'generated/proto/serverinfo_replay_match_pb';
import type { Response_DeckList } from 'generated/proto/response_deck_list_pb';
import type { ServerInfo_ChatMessage } from 'generated/proto/serverinfo_chat_message_pb';
import { NotifyUserData, ServerShutdownData, UserMessageData } from 'websocket/events/session/interfaces';
export interface ServerConnectParams {
@ -43,34 +50,34 @@ export interface AccountActivationParams extends ServerRegisterParams {
export interface ServerState {
initialized: boolean;
buddyList: User[];
ignoreList: User[];
buddyList: ServerInfo_User[];
ignoreList: ServerInfo_User[];
info: ServerStateInfo;
status: ServerStateStatus;
logs: ServerStateLogs;
user: User;
users: User[];
user: ServerInfo_User;
users: ServerInfo_User[];
sortUsersBy: ServerStateSortUsersBy;
messages: {
[userName: string]: UserMessageData[];
}
userInfo: {
[userName: string]: User;
[userName: string]: ServerInfo_User;
}
notifications: NotifyUserData[];
serverShutdown: ServerShutdownData;
banUser: string;
banHistory: {
[userName: string]: BanHistoryItem[];
[userName: string]: ServerInfo_Ban[];
};
warnHistory: {
[userName: string]: WarnHistoryItem[];
[userName: string]: ServerInfo_Warning[];
};
warnListOptions: WarnListItem[];
warnListOptions: Response_WarnList[];
warnUser: string;
adminNotes: { [userName: string]: string };
replays: ReplayMatch[];
backendDecks: DeckList | null;
replays: ServerInfo_ReplayMatch[];
backendDecks: Response_DeckList | null;
gamesOfUser: { [userName: string]: Game[] };
registrationError: string | null;
}
@ -88,9 +95,9 @@ export interface ServerStateInfo {
}
export interface ServerStateLogs {
room: LogItem[];
game: LogItem[];
chat: LogItem[];
room: ServerInfo_ChatMessage[];
game: ServerInfo_ChatMessage[];
chat: ServerInfo_ChatMessage[];
}
export interface ServerStateSortUsersBy extends SortBy {

3
webclient/src/store/server/server.reducer.spec.ts
View file

@ -1,4 +1,5 @@
import { StatusEnum, UserLevelFlag } from 'types';
import { StatusEnum } from 'types';
import { ServerInfo_User_UserLevelFlag as UserLevelFlag } from 'generated/proto/serverinfo_user_pb';
import { create } from '@bufbuild/protobuf';
import { Event_UserMessageSchema } from 'generated/proto/event_user_message_pb';
import { ServerInfo_DeckStorage_FolderSchema, ServerInfo_DeckStorage_TreeItemSchema } from 'generated/proto/serverinfo_deckstorage_pb';

26
webclient/src/store/server/server.reducer.ts
View file

@ -1,4 +1,6 @@
import { DeckStorageFolder, DeckStorageTreeItem, SortDirection, StatusEnum, UserLevelFlag, UserSortField } from 'types';
import { SortDirection, StatusEnum, UserSortField } from 'types';
import { ServerInfo_User_UserLevelFlag } from 'generated/proto/serverinfo_user_pb';
import type { ServerInfo_DeckStorage_Folder, ServerInfo_DeckStorage_TreeItem } from 'generated/proto/serverinfo_deckstorage_pb';
import { create } from '@bufbuild/protobuf';
import { Response_DeckListSchema } from 'generated/proto/response_deck_list_pb';
import { ServerInfo_DeckStorage_FolderSchema, ServerInfo_DeckStorage_TreeItemSchema } from 'generated/proto/serverinfo_deckstorage_pb';
@ -13,7 +15,11 @@ function splitPath(path: string): string[] {
return path ? path.split('/') : [];
}
function insertAtPath(folder: DeckStorageFolder, pathSegments: string[], item: DeckStorageTreeItem): DeckStorageFolder {
function insertAtPath(
folder: ServerInfo_DeckStorage_Folder,
pathSegments: string[],
item: ServerInfo_DeckStorage_TreeItem,
): ServerInfo_DeckStorage_Folder {
if (pathSegments.length === 0 || (pathSegments.length === 1 && pathSegments[0] === '')) {
return create(ServerInfo_DeckStorage_FolderSchema, { items: [...folder.items, item] });
}
@ -28,13 +34,13 @@ function insertAtPath(folder: DeckStorageFolder, pathSegments: string[], item: D
),
});
}
const created: DeckStorageTreeItem = create(ServerInfo_DeckStorage_TreeItemSchema, {
const created: ServerInfo_DeckStorage_TreeItem = create(ServerInfo_DeckStorage_TreeItemSchema, {
id: 0, name: head, folder: insertAtPath(create(ServerInfo_DeckStorage_FolderSchema, { items: [] }), tail, item)
});
return create(ServerInfo_DeckStorage_FolderSchema, { items: [...folder.items, created] });
}
function removeById(folder: DeckStorageFolder, id: number): DeckStorageFolder {
function removeById(folder: ServerInfo_DeckStorage_Folder, id: number): ServerInfo_DeckStorage_Folder {
return create(ServerInfo_DeckStorage_FolderSchema, {
items: folder.items
.filter(item => item.id !== id)
@ -44,7 +50,7 @@ function removeById(folder: DeckStorageFolder, id: number): DeckStorageFolder {
});
}
function removeByPath(folder: DeckStorageFolder, pathSegments: string[]): DeckStorageFolder {
function removeByPath(folder: ServerInfo_DeckStorage_Folder, pathSegments: string[]): ServerInfo_DeckStorage_Folder {
if (pathSegments.length === 0 || (pathSegments.length === 1 && pathSegments[0] === '')) {
return folder;
}
@ -410,8 +416,12 @@ export const serverReducer = (state = initialState, action: ServerAction) => {
return user;
}
let newLevel = user.userLevel;
newLevel = shouldBeMod ? (newLevel | UserLevelFlag.IsModerator) : (newLevel & ~UserLevelFlag.IsModerator);
newLevel = shouldBeJudge ? (newLevel | UserLevelFlag.IsJudge) : (newLevel & ~UserLevelFlag.IsJudge);
newLevel = shouldBeMod
? (newLevel | ServerInfo_User_UserLevelFlag.IsModerator)
: (newLevel & ~ServerInfo_User_UserLevelFlag.IsModerator);
newLevel = shouldBeJudge
? (newLevel | ServerInfo_User_UserLevelFlag.IsJudge)
: (newLevel & ~ServerInfo_User_UserLevelFlag.IsJudge);
return {
...user,
userLevel: newLevel,
@ -465,7 +475,7 @@ export const serverReducer = (state = initialState, action: ServerAction) => {
if (!state.backendDecks?.root) {
return state;
}
const newFolder: DeckStorageTreeItem = create(ServerInfo_DeckStorage_TreeItemSchema, {
const newFolder: ServerInfo_DeckStorage_TreeItem = create(ServerInfo_DeckStorage_TreeItemSchema, {
id: 0, name: action.dirName, folder: create(ServerInfo_DeckStorage_FolderSchema, { items: [] })
});
return {