Feat : add some events

client/containers.ts

@@ -1,47 +0,0 @@
-import type { IContainer, IFireGemsStack, IInteractibleContainer, IMarket, IMarketStack, IPlayableContainer, IPlayerBoard, IPlayerDiscard, IPlayerHand, IPlayerStack } from "../generic/containers.js"
-import type { ICard } from "../generic/index.js"
-
-export interface ICContainer<T> extends IContainer<T> {
-    onCardsAppend: (cards: Array<ICard>) => void
-    onDraw: (cards: Array<ICard>) => void
-    onRemoveCards: (cards: Array<ICard>) => void
-    onShuffle: () => void
-}
-
-export interface ICInteractibleContainer extends IInteractibleContainer {
-    onSacrifice: (card: ICard) => void
-}
-
-export interface ICPlayableContainer extends IPlayableContainer {
-    onDiscard: (card: ICard) => void
-}
-
-export interface ICMarketStack extends IMarketStack {
-
-}
-
-export interface ICMarket extends IMarket {
-    onBuy: (card: ICard) => void
-    onBuyInHand: (card: ICard) => void
-    onBuyInStack: (card: ICard) => void
-}
-
-export interface ICFireGemsStack extends IFireGemsStack {
-
-}
-
-export interface ICPlayerStack extends IPlayerStack {
-
-}
-
-export interface ICPlayerDiscard extends IPlayerDiscard {
-    onPutOnStack: (card: ICard) => void
-}
-
-export interface ICPlayerHand extends IPlayerHand {
-    onPutAllOnBoard: () => void
-}
-
-export interface ICPlayerBoard extends IPlayerBoard {
-    onStunChampion: (card: ICard) => void
-}

client/index.ts

@@ -1,61 +0,0 @@
-import type { ICard, IEffect, IGame, ILobby, IPlayer, ITeam, ITurn, IUser } from "../generic/index.js"
-import type { ISLobby } from "../server/index.js"
-
-export interface ICEffect extends IEffect {
-
-}
-
-export interface ICCard extends ICard {
-
-}
-
-export interface ICTurn extends ITurn {
-    onCardLock: (card: ICard) => void
-}
-
-export interface ICPlayer extends IPlayer {
-    onReadyStateChange: (ready: boolean) => void
-}
-
-export interface ICTeam extends ITeam {
-    damage: (amount: number) => void
-    join: () => void
-
-    onTakeDamage: (amount: number) => void
-    onPlayerAdd: (player: IPlayer) => void
-    onPlayerRemove: (player: IPlayer) => void
-    onStartTurn: () => void
-    onEndTurn: () => void
-    onDie: () => void
-}
-
-export interface ICGame extends IGame {
-    join: () => void
-    kick: (player: IPlayer) => void
-    leave: () => void
-    start: () => void
-
-    request_join: () => void
-    request_kick: (player: ICPlayer) => void
-    request_leave: () => void
-    request_start: () => void
-    request_changeRules: () => void
-    request_gameEnd: () => void
-
-    onRulesChange: () => void
-    onAddTeam: (team: ITeam) => void
-    onRemoveTeam: (team: ITeam) => void
-    onGameStart: () => void
-    onGameEnd: () => void
-}
-
-export interface ICUser extends IUser {
-
-}
-export interface ICLobby extends ILobby {
-    request_createGame: () => Promise<ReturnType<ISLobby["request_createGame"]>>
-    // request_login: () => Promise<ReturnType<ISLobby["request_login"]>>
-
-    onAddGame: (args: ReturnType<ISLobby["createGame"]>) => void
-    onRemoveGame: (args: ReturnType<ISLobby["removeGame"]>) => void
-}

containers.ts

@@ -0,0 +1,6 @@
+export enum ContainerVisibility {
+  NONE = "none",
+  ONLY_LAST = "only_last",
+  ALL = "all",
+  PROTECTED = "protected",
+}

generic/containers.ts

@@ -1,55 +0,0 @@
-import type { ICard, IGame, IGameObject, IPlayer } from "./index.js"
-
-export enum ContainerVisibility {
-    NONE = "none",
-    ONLY_LAST = "only_last",
-    ALL = "all",
-    PROTECTED = "protected"
-}
-
-export interface IContainer<T> extends IGameObject {
-    owner: T
-    readonly visibility: ContainerVisibility
-}
-
-export interface IInteractibleContainer extends IContainer<IPlayer> {
-    readonly visibility: ContainerVisibility.ALL | ContainerVisibility.PROTECTED
-    request_sacrifice: (card: ICard) => void
-}
-
-export interface IPlayableContainer extends IInteractibleContainer {
-    request_discard: (card: ICard) => void
-}
-
-export interface IMarketStack extends IContainer<IGame> {
-    readonly visibility: ContainerVisibility.NONE
-}
-
-export interface IMarket extends IContainer<IGame> {
-    readonly visibility: ContainerVisibility.ALL
-    request_buy: (card: ICard) => void
-    request_buyInHand: (card: ICard) => void
-    request_buyInStack: (card: ICard) => void
-}
-
-export interface IFireGemsStack extends IMarket {
-
-}
-
-export interface IPlayerStack extends IContainer<IPlayer> {
-    readonly visibility: ContainerVisibility.NONE
-}
-
-export interface IPlayerDiscard extends IInteractibleContainer {
-    readonly visibility: ContainerVisibility.ALL
-    request_putOnStack: (card: ICard) => void
-}
-
-export interface IPlayerHand extends IPlayableContainer {
-    readonly visibility: ContainerVisibility.PROTECTED
-}
-
-export interface IPlayerBoard extends IPlayableContainer {
-    readonly visibility: ContainerVisibility.ALL
-    request_stunChampion: (card: ICard) => void
-}

generic/index.ts

@@ -1,94 +0,0 @@
-import type { IFireGemsStack, IMarket, IMarketStack, IPlayerBoard, IPlayerDiscard, IPlayerHand } from "./containers.js"
-
-export const ClientQueryType = {
-    ACTION: "action",
-    SUBSCRIBE: "subscribe",
-    UNSUBSCRIBE: "unsubscribe",
-    LOGIN: "login"
-} as const
-
-export const ServerQueryType = {
-    CREATE: "create",
-    ERROR: "error",
-    ADD: "add",
-    REMOVE: "remove",
-} as const
-
-export type ClientMessageType = typeof ClientQueryType[keyof typeof ClientQueryType]
-export type ServerMessageType = typeof ServerQueryType[keyof typeof ServerQueryType]
-
-export interface ClientMessage {
-    uuid: string
-    type: ClientMessageType
-    target: string
-    method: string
-    args: { [key: string]: string }
-}
-
-export interface ServerMessage {
-    type: ServerMessageType
-    answer_to?: ClientMessage["uuid"]
-    args: { [key: string]: any }
-}
-
-
-export interface IGameObject {
-    uuid: string
-}
-
-export interface IEffect extends IGameObject {
-    request_use: () => void
-}
-
-export interface ICard extends IGameObject {
-
-}
-
-export interface ITurn extends IGameObject {
-    readonly effectsAvailables: Array<IEffect>
-    readonly cardsLocked: Set<ICard>
-    discardMarkers: number
-    fuckUMarkers: number
-    damageReserve: number
-    goldReserve: number
-    currentDiscardEffect: IEffect
-    request_lockCard: (card: ICard) => void
-}
-
-export interface IPlayer extends IGameObject {
-    readonly board: IPlayerBoard
-    readonly hand: IPlayerHand
-    readonly discard: IPlayerDiscard
-    ready: boolean
-    username: string
-    user: IUser
-    request_setReady: (value: boolean) => void
-}
-
-export interface ITeam extends IGameObject {
-    readonly players: Set<IPlayer>
-    color: string
-    health: number
-
-    request_damage: (amount: number) => void
-    request_join: (player: IPlayer) => void
-}
-
-export interface IGame extends IGameObject {
-    readonly marketStack: IMarketStack
-    readonly market: IMarket
-    readonly fireGems: IFireGemsStack
-    readonly owner: IPlayer
-    currentTurn?: ITeam
-    started: boolean
-    changeRules: () => void
-    end: () => void
-}
-
-export interface IUser extends IGameObject {
-
-}
-
-export interface ILobby extends IGameObject {
-
-}

index.ts

@@ -0,0 +1,67 @@
+export interface ClientMessage {
+  uuid: string;
+  target: string;
+  method: string;
+  args: { [key: string]: string };
+}
+
+export interface LobbyEvents {
+  newGame: (author: IUser, game: IGame) => void;
+  updateGame: (game: IGame) => void;
+  removeGame: (game: string) => void;
+}
+
+type TeamEvents = {
+  team_addPlayer: { gameObject: string; data: string };
+  team_removePlayer: { gameObject: string; data: string };
+};
+
+type TE = {
+  [T in keyof TeamEvents]: { event: T } & TeamEvents[T];
+};
+
+type ChildEvents = TE;
+
+export interface GameEvents {
+  start: () => void;
+  createTeam: (author: IUser, team: ITeam) => void;
+  removeTeam: (team: ITeam) => void;
+  createPlayer: (author: IUser, player: IPlayer) => void;
+  removePlayer: (player: IPlayer, reason?: string) => void;
+  childEvent: (event: ChildEvents[keyof ChildEvents]) => void;
+}
+export interface ICard extends IGameObject {}
+
+export interface IContainer extends IGameObject {
+  cards: Array<ICard | null>;
+}
+
+export interface IGameObject {
+  readonly uuid: string;
+}
+
+export interface IUser extends IGameObject {
+  readonly username: string;
+  readonly image: string;
+}
+
+export interface IPlayer extends IGameObject {
+  hand: IContainer;
+  discard: IContainer;
+  stack: IContainer;
+  board: IContainer;
+  user: IUser;
+}
+
+export interface ITeam extends IGameObject {
+  players: IUser[];
+}
+export interface IGame extends IGameObject {
+  readonly teams: ITeam[];
+  readonly market: IContainer;
+  readonly marketStack: IContainer;
+  readonly fireGems: IContainer;
+  readonly started: boolean;
+  readonly owner: string;
+  readonly rules: {};
+}

server/containers.ts

@@ -1,47 +0,0 @@
-import type { IContainer, IFireGemsStack, IInteractibleContainer, IMarket, IMarketStack, IPlayableContainer, IPlayerBoard, IPlayerDiscard, IPlayerHand, IPlayerStack } from "../generic/containers.js"
-import type { ISCard } from "./index.js"
-
-export interface ISContainer<T> extends IContainer<T> {
-    appendCards: (cards: Array<ISCard>) => void
-    draw: (amount: number) => Array<ISCard>
-    removeCards: (cards: Array<ISCard>) => void
-    shuffle: () => void
-}
-
-export interface ISInteractibleContainer extends IInteractibleContainer {
-    sacrifice: (card: ISCard) => void
-}
-
-export interface ISPlayableContainer extends IPlayableContainer {
-    discard: (card: ISCard) => void
-}
-
-export interface ISMarketStack extends IMarketStack {
-
-}
-
-export interface ISMarket extends IMarket {
-    buy: (card: ISCard) => void
-    buyInHand: (card: ISCard) => void
-    buyInStack: (card: ISCard) => void
-}
-
-export interface ISFireGemsStack extends IFireGemsStack {
-
-}
-
-export interface ISPlayerStack extends IPlayerStack {
-
-}
-
-export interface ISPlayerDiscard extends IPlayerDiscard {
-    putOnStack: (card: ISCard) => void
-}
-
-export interface ISPlayerHand extends IPlayerHand {
-    putAllOnBoard: () => void
-}
-
-export interface ISPlayerBoard extends IPlayerBoard {
-    stunChampion: (card: ISCard) => void
-}

server/index.ts

@@ -1,68 +0,0 @@
-import type { ICard, IEffect, IGame, ILobby, IPlayer, ITeam, ITurn, IUser, ServerMessage } from "../generic/index.js"
-import { WebSocket } from "ws"
-
-export interface ISClientProvider {
-    socket: WebSocket
-    send: (message: ServerMessage) => void
-}
-export interface ISQuery {
-    readonly provider: ISClientProvider
-    readonly args: { [key: string]: string } | string
-    readonly method?: string
-    readonly target: string
-    accept: (message: Omit<ServerMessage, "answer_to">) => void
-    cancel: (message: Omit<ServerMessage, "answer_to">) => void
-    error: (message: string) => void
-}
-
-export interface ISEffect extends IEffect {
-    use: () => void
-}
-
-export interface ISCard extends ICard {
-
-}
-
-export interface ISTurn extends ITurn {
-    lockCard: (card: ICard) => void
-}
-
-export interface ISPlayer extends IPlayer {
-    setReady: (ready: boolean) => void
-}
-
-export interface ISTeam extends ITeam {
-
-    damage: (amount: number) => void
-    addPlayer: (player: IPlayer) => void
-    removePlayer: (player: IPlayer) => void
-    startTurn: () => void
-    endTurn: () => void
-    die: () => void
-}
-
-export interface ISGame extends IGame {
-    addTeam: (team: ISTeam) => void
-    removeTeam: (team: ISTeam) => void
-    start: () => void
-
-    request_join: (query: ISQuery) => void
-    request_kick: (query: ISQuery) => void
-    request_leave: (query: ISQuery) => void
-    request_start: (query: ISQuery) => void
-    request_changeRules: (query: ISQuery) => void
-    request_gameEnd: (query: ISQuery) => void
-
-}
-
-export interface ISUser extends IUser {
-
-}
-
-export interface ISLobby extends ILobby {
-    createGame: () => string
-    removeGame: (game: ISGame) => void
-
-    request_createGame: (query: ISQuery) => void
-    // request_login: (query: ISQuery) => void
-}