Replaced "player" table by "lgUser" table and changed existing tables…

… schemas to a more complete version. Also added a custom logger and modified "lg" namespace and "create-game" command.

src/commands/create-game.ts

@@ -6,9 +6,14 @@ export default new app.Command({
   channelType: "guild",
   positional: [
     {
-      name: "lap",
+      name: "max_players",
       type: "number",
-      description: "The duration of a lap, in minutes",
+      description: "The max number of players",
+    },
+    {
+      name: "lap_duration",
+      type: "number",
+      description: "The duration of a lap, in seconds",
     },
     {
       name: "template",
@@ -19,10 +24,12 @@ export default new app.Command({
   async run(message) {
 
     const author = message.client.user
+    const lap_duration: number = message.args.lap_duration
+    const max_players: number = message.args.max_players
 
-    const [game, player] = await app.createGame(author)
+    const [game, player] = await app.createGame(author, max_players, lap_duration)
 
-    return message.channel.send(`New game created (\`${game}\`) by player \`${player}\``)
+    return message.channel.send(`New game created (\`${game}\`) by player \`${player}\`, with the following parameters : \n Max number of players : ${max_players} \n Lap duration : ${lap_duration}s`)
     // return message.channel.send(`New game created (\`${id}\`) with the following options : ${message.args.lap} mins and ${message.args.template}`)
   }
 })

src/namespaces/lg.ts

@@ -1,9 +1,11 @@
 import * as app from "#app"
 import ShortUniqueId from "short-unique-id"
 import gameTable from "#tables/game.ts"
-import playerTable from "#tables/player.ts"
+import lgUserTable from "#tables/lgUser.ts"
 
 
+const createLogger = new app.Logger({ section: "create" })
+
 export function genId(char: number): string {
     const id = new ShortUniqueId({ length: char })
 
@@ -12,25 +14,23 @@ export function genId(char: number): string {
 
 export async function findOrCreatePlayer(user: app.User): Promise<string> {
 
-    const data = await playerTable.query.where('discordId', parseInt(user.id)).returning('*')
+    const data = await lgUserTable.query.where('discordId', parseInt(user.id)).returning('*')
 
     console.log(data)
 
-    if (data) {
-
-
+    if (data[0]) {
 
-        const existing = data[0]?._id
+        const existing = data[0]._id
 
-        console.log(`Player "${existing}" already exists in db`)
+        app.log(`Player "${existing}" already exists in db`)
 
         return existing
 
     }
 
     else {
 
-        console.log(`Creating player in db...`)
+        createLogger.log(`Creating player in db...`)
 
         return createPlayer(user)
     }
@@ -39,40 +39,59 @@ export async function findOrCreatePlayer(user: app.User): Promise<string> {
 
 export async function createPlayer(user: app.User): Promise<string> {
 
-    const data = await playerTable.query.insert({
-        _id: genId(12),
-        discordId: parseInt(user.id)
-    })
-        .returning('_id')
-        .onConflict("discordId")
-        .merge(['discordId', 'alive', 'games'])
-        .returning('*')
+    try {
+        const data = await lgUserTable.query.insert({
+            _id: genId(12),
+            discordId: parseInt(user.id),
+            username: user.username,
+            created_at: Date.now()
+        })
+            .returning('_id')
+            .onConflict("discordId")
+            .merge(['discordId', 'games', 'created_at', 'friends', 'guild', 'hated', 'is_admin', 'level', 'nickname', 'username', 'wallet'])
+            .returning('*')
 
-    console.log(data)
+        console.log(data)
+
+        const newPlayer = data[0]._id
+
+        createLogger.success(`Created new player : ${newPlayer}`)
 
-    const newPlayer = data[0]._id
+        return newPlayer
+    } catch (err: any) {
+        createLogger.error(`An error occured during the player insertion : `, err)
 
-    console.log(`Created new player : ${newPlayer}`)
+        return err
+    }
 
-    return newPlayer
 }
 
-export async function createGame(user: app.User): Promise<[string, string]> {
+export async function createGame(user: app.User, max_players: number, lap_duration?: number): Promise<[string, string]> {
 
-    const author: string = await findOrCreatePlayer(user)
+    try {
 
-    const data = await gameTable.query.insert({
-        _id: genId(12),
-        gameId: genId(5),
-        created_at: Date.now(),
-        players: { 1: author }
-    }).returning('*')
+        const author: string | void = await findOrCreatePlayer(user)
 
-    console.log(data)
+        const data = await gameTable.query.insert({
+            _id: genId(12),
+            gameId: genId(5),
+            created_at: Date.now(),
+            max_players: max_players,
+            lap_duration: lap_duration,
+            players: { 1: author }
+        }).returning('*')
+
+        console.log(data)
 
-    const newGame = data[0].gameId
+        const newGame = data[0].gameId
 
-    console.log(`Created new game : ${newGame}`)
+        createLogger.success(`Created new game : ${newGame}`)
 
-    return [newGame, author]
+        return [newGame, author]
+
+    } catch (err: any) {
+
+        createLogger.error(`An error occured during the game insertion : `, err)
+        return err 
+    }
 }

src/tables/game.ts

@@ -3,20 +3,38 @@ import * as app from "#app"
 export interface Game {
   _id: string
   gameId: string
-  running: boolean
-  lap: number
   created_at: number
-  players: Object
+  ended_at: number
+  min_players: number
+  max_players: number
+  lap_duration: number
+  roles: object
+  has_started: boolean
+  is_running: boolean
+  lap: number
+  players: object
+  living: object
+  dead: object
+  logs: object
 }
 
 export default new app.Table<Game>({
   name: "game",
   setup: (table) => {
     table.string("_id").primary()
     table.string("gameId").notNullable()
-    table.boolean("running").defaultTo(true)
-    table.integer("lap").defaultTo(1)
     table.bigInteger("created_at")
+    table.bigInteger("ended_at").nullable()
+    table.integer("min_players").defaultTo(2)
+    table.integer("max_players").notNullable()
+    table.integer("lap_duration").defaultTo(120)
+    table.jsonb("roles").defaultTo({})
+    table.boolean("has_started").defaultTo(false)
+    table.boolean("is_running").defaultTo(false)
+    table.integer("lap").defaultTo(0)
     table.jsonb("players").defaultTo({})
+    table.jsonb("living").defaultTo({})
+    table.jsonb("dead").defaultTo({})
+    table.jsonb("logs").defaultTo({})
   },
 })

src/tables/lgUser.ts

@@ -0,0 +1,34 @@
+import * as app from "#app"
+
+export interface LGUser {
+  _id: string
+  discordId: number
+  username: string
+  created_at: number
+  nickname: string
+  wallet: object
+  level: number
+  games: object
+  friends: object
+  guild: object
+  hated: object
+  is_admin: boolean
+}
+
+export default new app.Table<LGUser>({
+  name: "player",
+  setup: (table) => {
+    table.string("_id").primary()
+    table.bigInteger("discordId").unique().notNullable()
+    table.string("username").defaultTo("")
+    table.bigInteger("created_at").notNullable()
+    table.string("nickname").defaultTo("")
+    table.jsonb("wallet").defaultTo({})
+    table.integer("level").defaultTo(0)
+    table.jsonb("games").defaultTo({})
+    table.jsonb("friends").defaultTo({})
+    table.jsonb("guild").defaultTo({})
+    table.jsonb("hated").defaultTo({})
+    table.boolean("is_admin").defaultTo(false)
+  },
+})