Major refractor, cleaning and improvements.

src/events/gameMaster/assetManager/object/list.ts

@@ -0,0 +1,24 @@
+import { Server } from 'socket.io'
+import { TSocket } from '../../../../utilities/types'
+import { Object } from '@prisma/client'
+import ObjectRepository from '../../../../repositories/objectRepository'
+
+interface IPayload {}
+
+/**
+ * Handle game master list object event
+ * @param socket
+ * @param io
+ */
+export default function (socket: TSocket, io: Server) {
+  socket.on('gm:object:list', async (data: any, callback: (response: Object[]) => void) => {
+    if (socket.character?.role !== 'gm') {
+      console.log(`---Character #${socket.character?.id} is not a game master.`)
+      return
+    }
+
+    // get all objects
+    const objects = await ObjectRepository.getAll()
+    callback(objects)
+  })
+}

src/events/gameMaster/assetManager/object/remove.ts

@@ -0,0 +1,48 @@
+import { Server } from 'socket.io'
+import { TSocket } from '../../../../utilities/types'
+import path from 'path'
+import fs from 'fs'
+import prisma from '../../../../utilities/prisma'
+
+interface IPayload {
+  object: string
+}
+
+/**
+ * Handle game master remove object event
+ * @param socket
+ * @param io
+ */
+export default function (socket: TSocket, io: Server) {
+  socket.on('gm:object:remove', async (data: IPayload, callback: (response: boolean) => void) => {
+    if (socket.character?.role !== 'gm') {
+      return
+    }
+
+    try {
+      await prisma.object.delete({
+        where: {
+          id: data.object
+        }
+      })
+
+      // get root path
+      const public_folder = path.join(process.cwd(), 'public', 'objects')
+
+      // remove the tile from the disk
+      const finalFilePath = path.join(public_folder, data.object + '.png')
+      fs.unlink(finalFilePath, (err) => {
+        if (err) {
+          console.log(err)
+          callback(false)
+          return
+        }
+
+        callback(true)
+      })
+    } catch (e) {
+      console.log(e)
+      callback(false)
+    }
+  })
+}

src/events/gameMaster/assetManager/object/update.ts

@@ -0,0 +1,50 @@
+import { Server } from 'socket.io'
+import { TSocket } from '../../../../utilities/types'
+import prisma from '../../../../utilities/prisma'
+
+type Payload = {
+  id: string
+  name: string
+  tags: string[]
+  originX: number
+  originY: number
+  isAnimated: boolean
+  frameSpeed: number
+  frameWidth: number
+  frameHeight: number
+}
+
+/**
+ * Handle game master object update event
+ * @param socket
+ * @param io
+ */
+export default function (socket: TSocket, io: Server) {
+  socket.on('gm:object:update', async (data: Payload, callback: (success: boolean) => void) => {
+    if (socket.character?.role !== 'gm') {
+      return
+    }
+
+    try {
+      const object = await prisma.object.update({
+        where: {
+          id: data.id
+        },
+        data: {
+          name: data.name,
+          tags: data.tags,
+          originX: data.originX,
+          originY: data.originY,
+          isAnimated: data.isAnimated,
+          frameSpeed: data.frameSpeed,
+          frameWidth: data.frameWidth,
+          frameHeight: data.frameHeight
+        }
+      })
+      callback(true)
+    } catch (error) {
+      console.error(error)
+      callback(false)
+    }
+  })
+}

src/events/gameMaster/assetManager/object/upload.ts

@@ -0,0 +1,54 @@
+import { Server } from 'socket.io'
+import { TSocket } from '../../../../utilities/types'
+import { writeFile } from 'node:fs/promises'
+import path from 'path'
+import fs from 'fs/promises'
+import prisma from '../../../../utilities/prisma'
+
+interface IObjectData {
+  [key: string]: Buffer
+}
+
+/**
+ * Handle game master upload object event
+ * @param socket
+ * @param io
+ */
+export default function (socket: TSocket, io: Server) {
+  socket.on('gm:object:upload', async (data: IObjectData, callback: (response: boolean) => void) => {
+    try {
+      if (socket.character?.role !== 'gm') {
+        callback(false)
+        return
+      }
+
+      const public_folder = path.join(process.cwd(), 'public', 'objects')
+
+      // Ensure the folder exists
+      await fs.mkdir(public_folder, { recursive: true })
+
+      const uploadPromises = Object.entries(data).map(async ([key, objectData]) => {
+        const object = await prisma.object.create({
+          data: {
+            name: key,
+            tags: [],
+            originX: 0,
+            originY: 0
+          }
+        })
+
+        const uuid = object.id
+        const filename = `${uuid}.png`
+        const finalFilePath = path.join(public_folder, filename)
+        await writeFile(finalFilePath, objectData)
+      })
+
+      await Promise.all(uploadPromises)
+
+      callback(true)
+    } catch (error) {
+      console.error('Error uploading tile:', error)
+      callback(false)
+    }
+  })
+}

src/events/gameMaster/assetManager/sprite/create.ts

@@ -0,0 +1,42 @@
+import { Server } from 'socket.io'
+import { TSocket } from '../../../../utilities/types'
+import path from 'path'
+import fs from 'fs/promises'
+import prisma from '../../../../utilities/prisma'
+
+/**
+ * Handle game master new sprite event
+ * @param socket
+ * @param io
+ */
+export default function (socket: TSocket, io: Server) {
+  socket.on('gm:sprite:create', async (data: undefined, callback: (response: boolean) => void) => {
+    try {
+      if (socket.character?.role !== 'gm') {
+        callback(false)
+        return
+      }
+
+      const public_folder = path.join(process.cwd(), 'public', 'sprites')
+
+      // Ensure the folder exists
+      await fs.mkdir(public_folder, { recursive: true })
+
+      const sprite = await prisma.sprite.create({
+        data: {
+          name: 'New sprite'
+        }
+      })
+      const uuid = sprite.id
+
+      // Create folder with uuid
+      const sprite_folder = path.join(public_folder, uuid)
+      await fs.mkdir(sprite_folder, { recursive: true })
+
+      callback(true)
+    } catch (error) {
+      console.error('Error creating sprite:', error)
+      callback(false)
+    }
+  })
+}

src/events/gameMaster/assetManager/sprite/list.ts

@@ -0,0 +1,24 @@
+import { Server } from 'socket.io'
+import { TSocket } from '../../../../utilities/types'
+import { Sprite } from '@prisma/client'
+import SpriteRepository from '../../../../repositories/spriteRepository'
+
+interface IPayload {}
+
+/**
+ * Handle game master list sprite event
+ * @param socket
+ * @param io
+ */
+export default function (socket: TSocket, io: Server) {
+  socket.on('gm:sprite:list', async (data: any, callback: (response: Sprite[]) => void) => {
+    if (socket.character?.role !== 'gm') {
+      console.log(`---Character #${socket.character?.id} is not a game master.`)
+      return
+    }
+
+    // get all sprites
+    const sprites = await SpriteRepository.getAll()
+    callback(sprites)
+  })
+}

src/events/gameMaster/assetManager/sprite/remove.ts

@@ -0,0 +1,47 @@
+import { Server } from 'socket.io'
+import { TSocket } from '../../../../utilities/types'
+import fs from 'fs'
+import path from 'path'
+import prisma from '../../../../utilities/prisma'
+
+type Payload = {
+  id: string
+}
+
+/**
+ * Handle game master remove sprite event
+ * @param socket
+ * @param io
+ */
+export default function (socket: TSocket, io: Server) {
+  socket.on('gm:sprite:remove', async (data: Payload, callback: (response: boolean) => void) => {
+    if (socket.character?.role !== 'gm') {
+      return
+    }
+
+    try {
+      // get root path
+      const public_folder = path.join(process.cwd(), 'public', 'sprites')
+
+      // remove the sprite folder from the disk
+      const finalFilePath = path.join(public_folder, data.id)
+
+      // check if the folder exists
+      if (fs.existsSync(finalFilePath)) {
+        // then remove
+        fs.rmdirSync(finalFilePath)
+      }
+
+      await prisma.sprite.delete({
+        where: {
+          id: data.id
+        }
+      })
+
+      callback(true)
+    } catch (e) {
+      console.log(e)
+      callback(false)
+    }
+  })
+}

src/events/gameMaster/assetManager/sprite/update.ts

@@ -0,0 +1,145 @@
+import { Server } from 'socket.io'
+import { TSocket } from '../../../../utilities/types'
+import prisma from '../../../../utilities/prisma'
+import type { Prisma, SpriteAction } from '@prisma/client'
+import path from 'path'
+import { writeFile, mkdir } from 'node:fs/promises'
+import sharp from 'sharp'
+
+type SpriteActionInput = Omit<SpriteAction, 'id' | 'spriteId' | 'frameWidth' | 'frameHeight'> & {
+  sprites: string[]
+}
+
+type Payload = {
+  id: string
+  name: string
+  spriteActions: Prisma.JsonValue
+}
+
+interface ProcessedSpriteAction extends SpriteActionInput {
+  frameWidth: number
+  frameHeight: number
+  buffersWithDimensions: Array<{
+    buffer: Buffer
+    width: number | undefined
+    height: number | undefined
+  }>
+}
+
+export default function (socket: TSocket, io: Server) {
+  socket.on('gm:sprite:update', async (data: Payload, callback: (success: boolean) => void) => {
+    if (socket.character?.role !== 'gm') {
+      callback(false)
+      return
+    }
+
+    try {
+      const parsedSpriteActions = validateSpriteActions(data.spriteActions)
+      const processedActions = await processSprites(parsedSpriteActions)
+
+      await updateDatabase(data.id, data.name, processedActions)
+      await saveSpritesToDisk(data.id, processedActions)
+
+      callback(true)
+    } catch (error) {
+      console.error('Error updating sprite:', error)
+      callback(false)
+    }
+  })
+}
+
+function validateSpriteActions(spriteActions: Prisma.JsonValue): SpriteActionInput[] {
+  try {
+    const parsed = JSON.parse(JSON.stringify(spriteActions)) as SpriteActionInput[]
+    if (!Array.isArray(parsed)) {
+      throw new Error('spriteActions is not an array')
+    }
+    return parsed
+  } catch (error) {
+    console.error('Error parsing spriteActions:', error)
+    throw error
+  }
+}
+
+async function processSprites(spriteActions: SpriteActionInput[]): Promise<ProcessedSpriteAction[]> {
+  return Promise.all(
+    spriteActions.map(async (spriteAction) => {
+      const { action, sprites } = spriteAction
+
+      if (!Array.isArray(sprites) || sprites.length === 0) {
+        throw new Error(`Invalid sprites array for action: ${action}`)
+      }
+
+      const buffersWithDimensions = await Promise.all(
+        sprites.map(async (sprite: string) => {
+          const buffer = Buffer.from(sprite.split(',')[1], 'base64')
+          const { width, height } = await sharp(buffer).metadata()
+          return { buffer, width, height }
+        })
+      )
+
+      const frameWidth = Math.max(...buffersWithDimensions.map((b) => b.width || 0))
+      const frameHeight = Math.max(...buffersWithDimensions.map((b) => b.height || 0))
+
+      return {
+        ...spriteAction,
+        frameWidth,
+        frameHeight,
+        buffersWithDimensions
+      }
+    })
+  )
+}
+
+async function updateDatabase(id: string, name: string, processedActions: ProcessedSpriteAction[]) {
+  await prisma.sprite.update({
+    where: { id },
+    data: {
+      name,
+      spriteActions: {
+        deleteMany: { spriteId: id },
+        create: processedActions.map(({ action, sprites, originX, originY, isAnimated, isLooping, frameWidth, frameHeight, frameSpeed }) => ({
+          action,
+          sprites,
+          originX,
+          originY,
+          isAnimated,
+          isLooping,
+          frameWidth,
+          frameHeight,
+          frameSpeed
+        }))
+      }
+    }
+  })
+}
+
+async function saveSpritesToDisk(id: string, processedActions: ProcessedSpriteAction[]) {
+  const publicFolder = path.join(process.cwd(), 'public', 'sprites', id)
+  await mkdir(publicFolder, { recursive: true })
+
+  await Promise.all(
+    processedActions.map(async ({ action, buffersWithDimensions, frameWidth, frameHeight }) => {
+      const combinedImage = await sharp({
+        create: {
+          width: frameWidth * buffersWithDimensions.length,
+          height: frameHeight,
+          channels: 4,
+          background: { r: 0, g: 0, b: 0, alpha: 0 }
+        }
+      })
+        .composite(
+          buffersWithDimensions.map(({ buffer }, index) => ({
+            input: buffer,
+            left: index * frameWidth,
+            top: 0
+          }))
+        )
+        .png()
+        .toBuffer()
+
+      const filename = path.join(publicFolder, `${action}.png`)
+      await writeFile(filename, combinedImage)
+    })
+  )
+}

src/events/gameMaster/assetManager/tile/list.ts

@@ -0,0 +1,24 @@
+import { Server } from 'socket.io'
+import { TSocket } from '../../../../utilities/types'
+import { Tile } from '@prisma/client'
+import TileRepository from '../../../../repositories/tileRepository'
+
+interface IPayload {}
+
+/**
+ * Handle game master list tile event
+ * @param socket
+ * @param io
+ */
+export default function (socket: TSocket, io: Server) {
+  socket.on('gm:tile:list', async (data: any, callback: (response: Tile[]) => void) => {
+    if (socket.character?.role !== 'gm') {
+      console.log(`---Character #${socket.character?.id} is not a game master.`)
+      return
+    }
+
+    // get all tiles
+    const tiles = await TileRepository.getAll()
+    callback(tiles)
+  })
+}

src/events/gameMaster/assetManager/tile/remove.ts

@@ -0,0 +1,48 @@
+import { Server } from 'socket.io'
+import { TSocket } from '../../../../utilities/types'
+import path from 'path'
+import fs from 'fs'
+import prisma from '../../../../utilities/prisma'
+
+type Payload = {
+  id: string
+}
+
+/**
+ * Handle game master remove tile event
+ * @param socket
+ * @param io
+ */
+export default function (socket: TSocket, io: Server) {
+  socket.on('gm:tile:remove', async (data: Payload, callback: (response: boolean) => void) => {
+    if (socket.character?.role !== 'gm') {
+      return
+    }
+
+    try {
+      await prisma.tile.delete({
+        where: {
+          id: data.id
+        }
+      })
+
+      // get root path
+      const public_folder = path.join(process.cwd(), 'public', 'tiles')
+
+      // remove the tile from the disk
+      const finalFilePath = path.join(public_folder, data.id + '.png')
+      fs.unlink(finalFilePath, (err) => {
+        if (err) {
+          console.log(err)
+          callback(false)
+          return
+        }
+
+        callback(true)
+      })
+    } catch (e) {
+      console.log(e)
+      callback(false)
+    }
+  })
+}

src/events/gameMaster/assetManager/tile/update.ts

@@ -0,0 +1,39 @@
+import { Server } from 'socket.io'
+import { TSocket } from '../../../../utilities/types'
+import prisma from '../../../../utilities/prisma'
+
+type Payload = {
+  id: string
+  name: string
+  tags: string[]
+}
+
+/**
+ * Handle game master tile update event
+ * @param socket
+ * @param io
+ */
+export default function (socket: TSocket, io: Server) {
+  socket.on('gm:tile:update', async (data: Payload, callback: (success: boolean) => void) => {
+    if (socket.character?.role !== 'gm') {
+      return
+    }
+
+    try {
+      const Tile = await prisma.tile.update({
+        where: {
+          id: data.id
+        },
+        data: {
+          name: data.name,
+          tags: data.tags
+        }
+      })
+
+      callback(true)
+    } catch (error) {
+      console.error(error)
+      callback(false)
+    }
+  })
+}

src/events/gameMaster/assetManager/tile/upload.ts

@@ -0,0 +1,50 @@
+import { Server } from 'socket.io'
+import { TSocket } from '../../../../utilities/types'
+import { writeFile } from 'node:fs/promises'
+import path from 'path'
+import fs from 'fs/promises'
+import prisma from '../../../../utilities/prisma'
+
+interface ITileData {
+  [key: string]: Buffer
+}
+
+/**
+ * Handle game master upload tile event
+ * @param socket
+ * @param io
+ */
+export default function (socket: TSocket, io: Server) {
+  socket.on('gm:tile:upload', async (data: ITileData, callback: (response: boolean) => void) => {
+    try {
+      if (socket.character?.role !== 'gm') {
+        callback(false)
+        return
+      }
+
+      const public_folder = path.join(process.cwd(), 'public', 'tiles')
+
+      // Ensure the folder exists
+      await fs.mkdir(public_folder, { recursive: true })
+
+      const uploadPromises = Object.entries(data).map(async ([key, tileData]) => {
+        const tile = await prisma.tile.create({
+          data: {
+            name: 'New tile'
+          }
+        })
+        const uuid = tile.id
+        const filename = `${uuid}.png`
+        const finalFilePath = path.join(public_folder, filename)
+        await writeFile(finalFilePath, tileData)
+      })
+
+      await Promise.all(uploadPromises)
+
+      callback(true)
+    } catch (error) {
+      console.error('Error uploading tile:', error)
+      callback(false)
+    }
+  })
+}