Mass replace parameter order (socket,io)>(io,socket), worked on queueing system

src/socketEvents/character/connect.ts

@@ -0,0 +1,26 @@
+import { Server } from 'socket.io'
+import { TSocket, ExtendedCharacter } from '../../utilities/types'
+import CharacterRepository from '../../repositories/characterRepository'
+import CharacterManager from '../../managers/characterManager'
+import QueueManager from '../../managers/queueManager'
+import SomeJob from '../../jobs/characterLeaveZone'
+
+type SocketResponseT = {
+  character_id: number
+}
+
+export default function (io: Server, socket: TSocket) {
+  socket.on('character:connect', async (data: SocketResponseT) => {
+    console.log('character:connect requested', data)
+    try {
+      const character = await CharacterRepository.getByUserAndId(socket?.user?.id as number, data.character_id)
+      if (!character) return
+      socket.characterId = character.id
+      await QueueManager.addToQueue(SomeJob, { someParam: 'value' }, socket)
+      CharacterManager.initCharacter(character as ExtendedCharacter)
+      socket.emit('character:connect', character)
+    } catch (error: any) {
+      console.log('character:connect error', error)
+    }
+  })
+}

src/socketEvents/character/create.ts

@@ -0,0 +1,51 @@
+import { Server } from 'socket.io'
+import { TSocket } from '../../utilities/types'
+import { Character } from '@prisma/client'
+import CharacterRepository from '../../repositories/characterRepository'
+import { ZCharacterCreate } from '../../utilities/zodTypes'
+import prisma from '../../utilities/prisma'
+import { gameLogger } from '../../utilities/logger'
+
+export default function (io: Server, socket: TSocket) {
+  socket.on('character:create', async (data: any) => {
+    console.log('character:create requested', data)
+    // zod validate
+    try {
+      data = ZCharacterCreate.parse(data)
+
+      const user_id = socket.user?.id as number
+
+      // Check if character name already exists
+      const characterExists = await CharacterRepository.getByName(data.name)
+
+      if (characterExists) {
+        return socket.emit('notification', { message: 'Character name already exists' })
+      }
+
+      let characters: Character[] = (await CharacterRepository.getByUserId(user_id)) as Character[]
+
+      if (characters.length >= 4) {
+        return socket.emit('notification', { message: 'You can only have 4 characters' })
+      }
+
+      const character: Character = await prisma.character.create({
+        data: {
+          name: data.name,
+          userId: user_id
+          // characterTypeId: 1 // @TODO set to chosen character type
+        }
+      })
+
+      characters = [...characters, character]
+
+      socket.emit('character:create:success')
+      socket.emit('character:list', characters)
+
+      gameLogger.info('character:create success')
+    } catch (error: any) {
+      console.log(error)
+      gameLogger.error(`character:create error: ${error.message}`)
+      return socket.emit('notification', { message: 'Could not create character. Please try again (later).' })
+    }
+  })
+}

src/socketEvents/character/delete.ts

@@ -0,0 +1,30 @@
+import { Server } from 'socket.io'
+import { TSocket } from '../../utilities/types'
+import { Character, Zone } from '@prisma/client'
+import CharacterRepository from '../../repositories/characterRepository'
+
+type TypePayload = {
+  character_id: number
+}
+
+type TypeResponse = {
+  zone: Zone
+  characters: Character[]
+}
+
+export default function (io: Server, socket: TSocket) {
+  socket.on('character:delete', async (data: TypePayload, callback: (response: TypeResponse) => void) => {
+    // zod validate
+    try {
+      await CharacterRepository.deleteByUserIdAndId(socket.user?.id as number, data.character_id as number)
+
+      const user_id = socket.user?.id as number
+      const characters: Character[] = (await CharacterRepository.getByUserId(user_id)) as Character[]
+
+      socket.emit('character:list', characters)
+    } catch (error: any) {
+      console.log(error)
+      return socket.emit('notification', { message: 'Character delete failed. Please try again.' })
+    }
+  })
+}

src/socketEvents/character/list.ts

@@ -0,0 +1,17 @@
+import { Socket, Server } from 'socket.io'
+import { TSocket } from '../../utilities/types'
+import { Character } from '@prisma/client'
+import CharacterRepository from '../../repositories/characterRepository'
+
+export default function CharacterList(io: Server, socket: TSocket) {
+  socket.on('character:list', async (data: any) => {
+    try {
+      console.log('character:list requested')
+      const user_id = socket.user?.id as number
+      const characters: Character[] = (await CharacterRepository.getByUserId(user_id)) as Character[]
+      socket.emit('character:list', characters)
+    } catch (error: any) {
+      console.log('character:list error', error)
+    }
+  })
+}

src/socketEvents/chat/gameMaster/alertCommand.ts

@@ -0,0 +1,28 @@
+import { Server } from 'socket.io'
+import { TSocket } from '../../../utilities/types'
+import { getArgs, isCommand } from '../../../utilities/chat'
+import CharacterRepository from '../../../repositories/characterRepository'
+
+type TypePayload = {
+  message: string
+}
+
+export default function (io: Server, socket: TSocket) {
+  socket.on('chat:send_message', async (data: TypePayload, callback: (response: boolean) => void) => {
+    try {
+      if (!isCommand(data.message, 'alert')) return
+
+      const args = getArgs('alert', data.message)
+
+      if (!args) return
+
+      const character = await CharacterRepository.getByUserAndId(socket.user?.id as number, socket.characterId as number)
+      if (!character) return
+
+      io.emit('notification', { title: 'Message from GM', message: args.join(' ') })
+      callback(true)
+    } catch (error: any) {
+      console.log(`---Error sending message: ${error.message}`)
+    }
+  })
+}

src/socketEvents/chat/gameMaster/teleportCommand.ts

@@ -0,0 +1,84 @@
+import { Server } from 'socket.io'
+import { TSocket } from '../../../utilities/types'
+import { getArgs, isCommand } from '../../../utilities/chat'
+import ZoneRepository from '../../../repositories/zoneRepository'
+import CharacterManager from '../../../managers/characterManager'
+import { gameMasterLogger } from '../../../utilities/logger'
+
+type TypePayload = {
+  message: string
+}
+
+export default class TeleportCommandEvent {
+  constructor(
+    private readonly io: Server,
+    private readonly socket: TSocket
+  ) {}
+
+  public listen(): void {
+    this.socket.on('chat:send_message', this.handleTeleportCommand.bind(this))
+  }
+
+  private async handleTeleportCommand(data: TypePayload, callback: (response: boolean) => void): Promise<void> {
+    try {
+      const character = CharacterManager.getCharacterFromSocket(this.socket)
+      if (!character) {
+        this.socket.emit('notification', { title: 'Server message', message: 'Character not found' })
+        return
+      }
+
+      if (!isCommand(data.message, 'teleport')) return
+
+      const args = getArgs('teleport', data.message)
+
+      if (!args || args.length !== 1) {
+        this.socket.emit('notification', { title: 'Server message', message: 'Usage: /teleport <zoneId>' })
+        return
+      }
+
+      const zoneId = parseInt(args[0], 10)
+      if (isNaN(zoneId)) {
+        this.socket.emit('notification', { title: 'Server message', message: 'Invalid zone ID' })
+        return
+      }
+
+      const zone = await ZoneRepository.getById(zoneId)
+      if (!zone) {
+        this.socket.emit('notification', { title: 'Server message', message: 'Zone not found' })
+        return
+      }
+
+      if (character.zoneId === zone.id) {
+        this.socket.emit('notification', { title: 'Server message', message: 'You are already in that zone' })
+        return
+      }
+
+      // Remove character from current zone
+      this.io.to(character.zoneId.toString()).emit('zone:character:leave', character.id)
+      this.socket.leave(character.zoneId.toString())
+
+      // Add character to new zone
+      this.io.to(zone.id.toString()).emit('zone:character:join', character)
+      this.socket.join(zone.id.toString())
+
+      character.zoneId = zone.id
+      character.positionX = 0
+      character.positionY = 0
+
+      character.resetMovement = true
+
+      this.socket.emit('zone:character:teleport', {
+        zone,
+        characters: CharacterManager.getCharactersInZone(zone)
+      })
+
+      this.socket.emit('notification', { title: 'Server message', message: `You have been teleported to ${zone.name}` })
+      gameMasterLogger.info('teleport', `Character ${character.id} teleported to zone ${zone.id}`)
+
+      callback(true)
+    } catch (error: any) {
+      gameMasterLogger.error(`Error in teleport command: ${error.message}`)
+      this.socket.emit('notification', { title: 'Server message', message: 'An error occurred while teleporting' })
+    }
+  }
+}

src/socketEvents/chat/sendMessage.ts

@@ -0,0 +1,54 @@
+import { Server } from 'socket.io'
+import { TSocket } from '../../utilities/types'
+import CharacterRepository from '../../repositories/characterRepository'
+import ZoneRepository from '../../repositories/zoneRepository'
+import { isCommand } from '../../utilities/chat'
+import { gameLogger } from '../../utilities/logger'
+
+type TypePayload = {
+  message: string
+}
+
+export default class ChatMessageEvent {
+  constructor(
+    private readonly io: Server,
+    private readonly socket: TSocket
+  ) {}
+
+  public listen(): void {
+    this.socket.on('chat:send_message', this.handleChatMessage.bind(this))
+  }
+
+  private async handleChatMessage(data: TypePayload, callback: (response: boolean) => void): Promise<void> {
+    try {
+      if (!data.message || isCommand(data.message)) {
+        callback(false)
+        return
+      }
+
+      const character = await CharacterRepository.getByUserAndId(this.socket.user?.id as number, this.socket.characterId as number)
+      if (!character) {
+        gameLogger.error('chat:send_message error', 'Character not found')
+        callback(false)
+        return
+      }
+
+      const zone = await ZoneRepository.getById(character.zoneId)
+      if (!zone) {
+        gameLogger.error('chat:send_message error', 'Zone not found')
+        callback(false)
+        return
+      }
+
+      callback(true)
+
+      this.io.to(zone.id.toString()).emit('chat:message', {
+        character: character,
+        message: data.message
+      })
+    } catch (error: any) {
+      gameLogger.error('chat:send_message error', error.message)
+      callback(false)
+    }
+  }
+}

src/socketEvents/disconnect.ts

@@ -0,0 +1,28 @@
+import { Server } from 'socket.io'
+import { TSocket } from '../utilities/types'
+import CharacterManager from '../managers/characterManager'
+
+export default function (io: Server, socket: TSocket) {
+  socket.on('disconnect', async (data: any) => {
+    if (!socket.user) {
+      console.log('User disconnected but had no user set')
+      return
+    }
+
+    io.emit('user:disconnect', socket.user.id)
+
+    const character = CharacterManager.getCharacterFromSocket(socket)
+
+    if (!character) {
+      console.log('User disconnected but had no character set')
+      return
+    }
+
+    console.log('User disconnected along with their character')
+
+    await CharacterManager.removeCharacter(character)
+
+    io.in(character.zoneId.toString()).emit('zone:character:leave', character.id)
+    io.emit('character:disconnect', character.id)
+  })
+}

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

@@ -0,0 +1,28 @@
+import { Server } from 'socket.io'
+import { TSocket } from '../../../../utilities/types'
+import { Object } from '@prisma/client'
+import ObjectRepository from '../../../../repositories/objectRepository'
+import CharacterManager from '../../../../managers/characterManager'
+import characterRepository from '../../../../repositories/characterRepository'
+
+interface IPayload {}
+
+/**
+ * Handle game master list object event
+ * @param socket
+ * @param io
+ */
+export default function (io: Server, socket: TSocket) {
+  socket.on('gm:object:list', async (data: any, callback: (response: Object[]) => void) => {
+    const character = await characterRepository.getById(socket.characterId as number)
+    if (!character) return callback([])
+
+    if (character.role !== 'gm') {
+      return callback([])
+    }
+
+    // get all objects
+    const objects = await ObjectRepository.getAll()
+    callback(objects)
+  })
+}

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

@@ -0,0 +1,53 @@
+import { Server } from 'socket.io'
+import { TSocket } from '../../../../utilities/types'
+import path from 'path'
+import fs from 'fs'
+import prisma from '../../../../utilities/prisma'
+import CharacterManager from '../../../../managers/characterManager'
+import characterRepository from '../../../../repositories/characterRepository'
+
+interface IPayload {
+  object: string
+}
+
+/**
+ * Handle game master remove object event
+ * @param socket
+ * @param io
+ */
+export default function (io: Server, socket: TSocket) {
+  socket.on('gm:object:remove', async (data: IPayload, callback: (response: boolean) => void) => {
+    const character = await characterRepository.getById(socket.characterId as number)
+    if (!character) return callback(false)
+
+    if (character.role !== 'gm') {
+      return callback(false)
+    }
+
+    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/socketEvents/gameMaster/assetManager/object/update.ts

@@ -0,0 +1,55 @@
+import { Server } from 'socket.io'
+import { TSocket } from '../../../../utilities/types'
+import prisma from '../../../../utilities/prisma'
+import CharacterManager from '../../../../managers/characterManager'
+import characterRepository from '../../../../repositories/characterRepository'
+
+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 (io: Server, socket: TSocket) {
+  socket.on('gm:object:update', async (data: Payload, callback: (success: boolean) => void) => {
+    const character = await characterRepository.getById(socket.characterId as number)
+    if (!character) return callback(false)
+
+    if (character.role !== 'gm') {
+      return callback(false)
+    }
+
+    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/socketEvents/gameMaster/assetManager/object/upload.ts

@@ -0,0 +1,71 @@
+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'
+import sharp from 'sharp'
+import characterRepository from '../../../../repositories/characterRepository'
+import { gameMasterLogger } from '../../../../utilities/logger'
+
+interface IObjectData {
+  [key: string]: Buffer
+}
+
+export default class ObjectUploadEvent {
+  constructor(
+    private readonly io: Server,
+    private readonly socket: TSocket
+  ) {}
+
+  public listen(): void {
+    this.socket.on('gm:object:upload', this.handleObjectUpload.bind(this))
+  }
+
+  private async handleObjectUpload(data: IObjectData, callback: (response: boolean) => void): Promise<void> {
+    try {
+      const character = await characterRepository.getById(this.socket.characterId as number)
+      if (!character) return callback(false)
+
+      if (character.role !== 'gm') {
+        return callback(false)
+      }
+      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]) => {
+        // Get image dimensions
+        const metadata = await sharp(objectData).metadata()
+        const width = metadata.width || 0
+        const height = metadata.height || 0
+
+        const object = await prisma.object.create({
+          data: {
+            name: key,
+            tags: [],
+            originX: 0,
+            originY: 0,
+            frameWidth: width,
+            frameHeight: height
+          }
+        })
+
+        const uuid = object.id
+        const filename = `${uuid}.png`
+        const finalFilePath = path.join(public_folder, filename)
+        await writeFile(finalFilePath, objectData)
+
+        gameMasterLogger.info('gm:object:upload', `Object ${key} uploaded with id ${uuid}`)
+      })
+
+      await Promise.all(uploadPromises)
+
+      callback(true)
+    } catch (error: any) {
+      gameMasterLogger.error('gm:object:upload error', error.message)
+      callback(false)
+    }
+  }
+}

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

@@ -0,0 +1,46 @@
+import { Server } from 'socket.io'
+import { TSocket } from '../../../../utilities/types'
+import path from 'path'
+import fs from 'fs/promises'
+import prisma from '../../../../utilities/prisma'
+import CharacterManager from '../../../../managers/characterManager'
+import characterRepository from '../../../../repositories/characterRepository'
+
+/**
+ * Handle game master new sprite event
+ * @param socket
+ * @param io
+ */
+export default function (io: Server, socket: TSocket) {
+  socket.on('gm:sprite:create', async (data: undefined, callback: (response: boolean) => void) => {
+    try {
+      const character = await characterRepository.getById(socket.characterId as number)
+      if (!character) return callback(false)
+
+      if (character.role !== 'gm') {
+        return callback(false)
+      }
+
+      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/socketEvents/gameMaster/assetManager/sprite/delete.ts

@@ -0,0 +1,60 @@
+import { Server } from 'socket.io'
+import { TSocket } from '../../../../utilities/types'
+import fs from 'fs'
+import path from 'path'
+import prisma from '../../../../utilities/prisma'
+import CharacterManager from '../../../../managers/characterManager'
+import { gameMasterLogger } from '../../../../utilities/logger'
+
+type Payload = {
+  id: string
+}
+
+export default class GMSpriteDeleteEvent {
+  private readonly public_folder: string
+
+  constructor(
+    private readonly io: Server,
+    private readonly socket: TSocket
+  ) {
+    this.public_folder = path.join(process.cwd(), 'public', 'sprites')
+  }
+
+  public listen(): void {
+    this.socket.on('gm:sprite:delete', this.handleSpriteDelete.bind(this))
+  }
+
+  private async handleSpriteDelete(data: Payload, callback: (response: boolean) => void): Promise<void> {
+    const character = CharacterManager.getCharacterFromSocket(this.socket)
+    if (character?.role !== 'gm') {
+      return callback(false)
+    }
+
+    try {
+      await this.deleteSpriteFolder(data.id)
+      await this.deleteSpriteFromDatabase(data.id)
+
+      gameMasterLogger.info(`Sprite ${data.id} deleted.`)
+      callback(true)
+    } catch (error: any) {
+      gameMasterLogger.error('gm:sprite:delete error', error.message)
+      callback(false)
+    }
+  }
+
+  private async deleteSpriteFolder(spriteId: string): Promise<void> {
+    const finalFilePath = path.join(this.public_folder, spriteId)
+
+    if (fs.existsSync(finalFilePath)) {
+      await fs.promises.rmdir(finalFilePath, { recursive: true })
+    }
+  }
+
+  private async deleteSpriteFromDatabase(spriteId: string): Promise<void> {
+    await prisma.sprite.delete({
+      where: {
+        id: spriteId
+      }
+    })
+  }
+}

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

@@ -0,0 +1,28 @@
+import { Server } from 'socket.io'
+import { TSocket } from '../../../../utilities/types'
+import { Sprite } from '@prisma/client'
+import SpriteRepository from '../../../../repositories/spriteRepository'
+import CharacterManager from '../../../../managers/characterManager'
+import characterRepository from '../../../../repositories/characterRepository'
+
+interface IPayload {}
+
+/**
+ * Handle game master list sprite event
+ * @param socket
+ * @param io
+ */
+export default function (io: Server, socket: TSocket) {
+  socket.on('gm:sprite:list', async (data: any, callback: (response: Sprite[]) => void) => {
+    const character = await characterRepository.getById(socket.characterId as number)
+    if (!character) return callback([])
+
+    if (character.role !== 'gm') {
+      return callback([])
+    }
+
+    // get all sprites
+    const sprites = await SpriteRepository.getAll()
+    callback(sprites)
+  })
+}

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

@@ -0,0 +1,146 @@
+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'
+import CharacterManager from '../../../../managers/characterManager'
+
+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 (io: Server, socket: TSocket) {
+  socket.on('gm:sprite:update', async (data: Payload, callback: (success: boolean) => void) => {
+    const character = CharacterManager.getCharacterFromSocket(socket)
+    if (character?.role !== 'gm') {
+      return callback(false)
+    }
+
+    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/socketEvents/gameMaster/assetManager/tile/delete.ts

@@ -0,0 +1,67 @@
+import path from 'path'
+import fs from 'fs/promises'
+import { Server } from 'socket.io'
+import { TSocket } from '../../../../utilities/types'
+import prisma from '../../../../utilities/prisma'
+import characterRepository from '../../../../repositories/characterRepository'
+import { gameMasterLogger } from '../../../../utilities/logger'
+
+type Payload = {
+  id: string
+}
+
+export default class GMTileDeleteEvent {
+  private readonly public_folder: string
+
+  constructor(
+    private readonly io: Server,
+    private readonly socket: TSocket
+  ) {
+    this.public_folder = path.join(process.cwd(), 'public', 'tiles')
+  }
+
+  public listen(): void {
+    this.socket.on('gm:tile:delete', this.handleTileDelete.bind(this))
+  }
+
+  private async handleTileDelete(data: Payload, callback: (response: boolean) => void): Promise<void> {
+    const character = await characterRepository.getById(this.socket.characterId as number)
+    if (!character) return callback(false)
+
+    if (character.role !== 'gm') {
+      return
+    }
+
+    try {
+      gameMasterLogger.info(`Deleting tile ${data.id}`)
+      await this.deleteTileFromDatabase(data.id)
+      await this.deleteTileFile(data.id)
+
+      gameMasterLogger.info(`Tile ${data.id} deleted successfully.`)
+      callback(true)
+    } catch (error: any) {
+      gameMasterLogger.error('gm:tile:delete error', error.message)
+      callback(false)
+    }
+  }
+
+  private async deleteTileFromDatabase(tileId: string): Promise<void> {
+    await prisma.tile.delete({
+      where: {
+        id: tileId
+      }
+    })
+  }
+
+  private async deleteTileFile(tileId: string): Promise<void> {
+    const finalFilePath = path.join(this.public_folder, `${tileId}.png`)
+    try {
+      await fs.unlink(finalFilePath)
+    } catch (error: any) {
+      if (error.code !== 'ENOENT') {
+        throw error
+      }
+      gameMasterLogger.warn(`File ${finalFilePath} does not exist.`)
+    }
+  }
+}

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

@@ -0,0 +1,28 @@
+import { Server } from 'socket.io'
+import { TSocket } from '../../../../utilities/types'
+import { Tile } from '@prisma/client'
+import TileRepository from '../../../../repositories/tileRepository'
+import CharacterManager from '../../../../managers/characterManager'
+import characterRepository from '../../../../repositories/characterRepository'
+
+interface IPayload {}
+
+/**
+ * Handle game master list tile event
+ * @param socket
+ * @param io
+ */
+export default function (io: Server, socket: TSocket) {
+  socket.on('gm:tile:list', async (data: any, callback: (response: Tile[]) => void) => {
+    const character = await characterRepository.getById(socket.characterId as number)
+    if (!character) return
+
+    if (character.role !== 'gm') {
+      return
+    }
+
+    // get all tiles
+    const tiles = await TileRepository.getAll()
+    callback(tiles)
+  })
+}

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

@@ -0,0 +1,44 @@
+import { Server } from 'socket.io'
+import { TSocket } from '../../../../utilities/types'
+import prisma from '../../../../utilities/prisma'
+import CharacterManager from '../../../../managers/characterManager'
+import characterRepository from '../../../../repositories/characterRepository'
+
+type Payload = {
+  id: string
+  name: string
+  tags: string[]
+}
+
+/**
+ * Handle game master tile update event
+ * @param socket
+ * @param io
+ */
+export default function (io: Server, socket: TSocket) {
+  socket.on('gm:tile:update', async (data: Payload, callback: (success: boolean) => void) => {
+    const character = await characterRepository.getById(socket.characterId as number)
+    if (!character) return callback(false)
+
+    if (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/socketEvents/gameMaster/assetManager/tile/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'
+import characterRepository from '../../../../repositories/characterRepository'
+import { gameMasterLogger } from '../../../../utilities/logger'
+
+interface ITileData {
+  [key: string]: Buffer
+}
+
+/**
+ * Handle game master upload tile event
+ * @param socket
+ * @param io
+ */
+export default function (io: Server, socket: TSocket) {
+  socket.on('gm:tile:upload', async (data: ITileData, callback: (response: boolean) => void) => {
+    try {
+      const character = await characterRepository.getById(socket.characterId as number)
+      if (!character) return callback(false)
+
+      if (character.role !== 'gm') {
+        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) {
+      gameMasterLogger.error('Error uploading tile:', error)
+      callback(false)
+    }
+  })
+}

src/socketEvents/gameMaster/zoneEditor/create.ts

@@ -0,0 +1,52 @@
+import { Server } from 'socket.io'
+import { TSocket } from '../../../utilities/types'
+import ZoneRepository from '../../../repositories/zoneRepository'
+import { Zone } from '@prisma/client'
+import prisma from '../../../utilities/prisma'
+import characterRepository from '../../../repositories/characterRepository'
+import { gameMasterLogger } from '../../../utilities/logger'
+
+type Payload = {
+  name: string
+  width: number
+  height: number
+}
+
+/**
+ * Handle game master zone create event
+ * @param socket
+ * @param io
+ */
+export default function (io: Server, socket: TSocket) {
+  socket.on('gm:zone_editor:zone:create', async (data: Payload, callback: (response: Zone[]) => void) => {
+    const character = await characterRepository.getById(socket.characterId as number)
+    if (!character) return
+
+    if (character.role !== 'gm') {
+      gameMasterLogger.info(`User ${character.id} tried to create zone but is not a game master.`)
+      return
+    }
+
+    gameMasterLogger.info(`User ${character.id} has created a new zone via zone editor.`)
+
+    let zoneList: Zone[] = []
+    try {
+      const zone = await prisma.zone.create({
+        data: {
+          name: data.name,
+          width: data.width,
+          height: data.height,
+          tiles: Array.from({ length: data.height }, () => Array.from({ length: data.width }, () => 'blank_tile'))
+        }
+      })
+
+      zoneList = await ZoneRepository.getAll()
+      callback(zoneList)
+      // send over zone and characters to socket
+    } catch (e) {
+      console.error(e)
+      socket.emit('notification', { message: 'Failed to create zoneEditor.' })
+      callback(zoneList)
+    }
+  })
+}

src/socketEvents/gameMaster/zoneEditor/delete.ts

@@ -0,0 +1,49 @@
+import { Server } from 'socket.io'
+import { TSocket } from '../../../utilities/types'
+import ZoneRepository from '../../../repositories/zoneRepository'
+import prisma from '../../../utilities/prisma'
+import characterRepository from '../../../repositories/characterRepository'
+import { gameMasterLogger } from '../../../utilities/logger'
+
+type Payload = {
+  zoneId: number
+}
+
+/**
+ * Handle game master zone delete event
+ * @param socket
+ * @param io
+ */
+export default function (io: Server, socket: TSocket) {
+  socket.on('gm:zone_editor:zone:delete', async (data: Payload, callback: (response: boolean) => void) => {
+    const character = await characterRepository.getById(socket.characterId as number)
+    if (!character) return
+
+    if (character.role !== 'gm') {
+      gameMasterLogger.info(`User ${character.id} tried to delete zone but is not a game master.`)
+      return
+    }
+
+    gameMasterLogger.info(`User ${character.id} has deleted a zone via zone editor.`)
+
+    try {
+      const zone = await ZoneRepository.getById(data.zoneId)
+
+      if (!zone) {
+        console.log(`---Zone not found.`)
+        return
+      }
+
+      await prisma.zone.delete({
+        where: {
+          id: data.zoneId
+        }
+      })
+
+      callback(true)
+    } catch (e) {
+      console.error(e)
+      callback(false)
+    }
+  })
+}

src/socketEvents/gameMaster/zoneEditor/list.ts

@@ -0,0 +1,35 @@
+import { Server } from 'socket.io'
+import { TSocket } from '../../../utilities/types'
+import { Zone } from '@prisma/client'
+import ZoneRepository from '../../../repositories/zoneRepository'
+import characterRepository from '../../../repositories/characterRepository'
+import { gameMasterLogger } from '../../../utilities/logger'
+
+interface IPayload {}
+
+/**
+ * Handle game master list zones event
+ * @param socket
+ * @param io
+ */
+export default function (io: Server, socket: TSocket) {
+  socket.on('gm:zone_editor:zone:list', async (data: IPayload, callback: (response: Zone[]) => void) => {
+    const character = await characterRepository.getById(socket.characterId as number)
+    if (!character) return
+
+    if (character.role !== 'gm') {
+      gameMasterLogger.info(`User ${character.id} tried to list zones but is not a game master.`)
+      return
+    }
+
+    gameMasterLogger.info(`User ${character.id} has requested zone list via zone editor.`)
+
+    try {
+      const zones = await ZoneRepository.getAll()
+      callback(zones)
+    } catch (e) {
+      console.error(e)
+      callback([])
+    }
+  })
+}

src/socketEvents/gameMaster/zoneEditor/request.ts

@@ -0,0 +1,47 @@
+import { Server } from 'socket.io'
+import { TSocket } from '../../../utilities/types'
+import ZoneRepository from '../../../repositories/zoneRepository'
+import { Zone } from '@prisma/client'
+import characterRepository from '../../../repositories/characterRepository'
+import { gameMasterLogger } from '../../../utilities/logger'
+
+interface IPayload {
+  zoneId: number
+}
+
+/**
+ * Handle game master zone request event
+ * @param socket
+ * @param io
+ */
+export default function (io: Server, socket: TSocket) {
+  socket.on('gm:zone_editor:zone:request', async (data: IPayload, callback: (response: Zone) => void) => {
+    const character = await characterRepository.getById(socket.characterId as number)
+    if (!character) return
+
+    if (character.role !== 'gm') {
+      gameMasterLogger.info(`User ${character!.id} tried to request zone but is not a game master.`)
+      return
+    }
+
+    gameMasterLogger.info(`User ${character.id} has requested zone via zone editor.`)
+
+    if (!data.zoneId) {
+      gameMasterLogger.info(`User ${character.id} tried to request zone but did not provide a zone id.`)
+      return
+    }
+
+    try {
+      const zone = await ZoneRepository.getById(data.zoneId)
+
+      if (!zone) {
+        gameMasterLogger.info(`User ${character.id} tried to request zone ${data.zoneId} but it does not exist.`)
+        return
+      }
+
+      callback(zone)
+    } catch (e) {
+      console.error(e)
+    }
+  })
+}

src/socketEvents/gameMaster/zoneEditor/update.ts

@@ -0,0 +1,122 @@
+import { Server } from 'socket.io'
+import { TSocket } from '../../../utilities/types'
+import ZoneRepository from '../../../repositories/zoneRepository'
+import { Zone, ZoneEventTileType, ZoneObject } from '@prisma/client'
+import prisma from '../../../utilities/prisma'
+import zoneManager from '../../../managers/zoneManager'
+import characterRepository from '../../../repositories/characterRepository'
+import { gameMasterLogger } from '../../../utilities/logger'
+
+interface IPayload {
+  zoneId: number
+  name: string
+  width: number
+  height: number
+  tiles: string[][]
+  pvp: boolean
+  zoneEventTiles: {
+    type: ZoneEventTileType
+    positionX: number
+    positionY: number
+    teleport?: {
+      toZoneId: number
+      toPositionX: number
+      toPositionY: number
+    }
+  }[]
+  zoneObjects: ZoneObject[]
+}
+
+/**
+ * Handle game master zone update event
+ * @param socket
+ * @param io
+ */
+export default function (io: Server, socket: TSocket) {
+  socket.on('gm:zone_editor:zone:update', async (data: IPayload, callback: (response: Zone) => void) => {
+    const character = await characterRepository.getById(socket.characterId as number)
+    if (!character) return
+
+    if (character.role !== 'gm') {
+      gameMasterLogger.info(`User ${character.id} tried to update zone but is not a game master.`)
+      return
+    }
+
+    gameMasterLogger.info(`User ${character.id} has updated zone via zone editor.`)
+
+    if (!data.zoneId) {
+      gameMasterLogger.info(`User ${character.id} tried to update zone but did not provide a zone id.`)
+      return
+    }
+
+    try {
+      let zone = await ZoneRepository.getById(data.zoneId)
+
+      if (!zone) {
+        gameMasterLogger.info(`User ${character.id} tried to update zone ${data.zoneId} but it does not exist.`)
+        return
+      }
+
+      await prisma.zone.update({
+        where: {
+          id: data.zoneId
+        },
+        data: {
+          name: data.name,
+          width: data.width,
+          height: data.height,
+          tiles: data.tiles,
+          pvp: data.pvp,
+          zoneEventTiles: {
+            deleteMany: {
+              zoneId: data.zoneId // Ensure only event tiles related to the zone are deleted
+            },
+            // Save new zone event tiles
+            create: data.zoneEventTiles.map((zoneEventTile) => ({
+              type: zoneEventTile.type,
+              positionX: zoneEventTile.positionX,
+              positionY: zoneEventTile.positionY,
+              ...(zoneEventTile.type === 'TELEPORT' && zoneEventTile.teleport
+                ? {
+                    teleport: {
+                      create: {
+                        toZoneId: zoneEventTile.teleport.toZoneId,
+                        toPositionX: zoneEventTile.teleport.toPositionX,
+                        toPositionY: zoneEventTile.teleport.toPositionY
+                      }
+                    }
+                  }
+                : {})
+            }))
+          },
+          zoneObjects: {
+            deleteMany: {
+              zoneId: data.zoneId // Ensure only objects related to the zone are deleted
+            },
+            // Save new zone objects
+            create: data.zoneObjects.map((zoneObject) => ({
+              objectId: zoneObject.objectId,
+              depth: zoneObject.depth,
+              positionX: zoneObject.positionX,
+              positionY: zoneObject.positionY
+            }))
+          }
+        }
+      })
+
+      zone = await ZoneRepository.getById(data.zoneId)
+
+      if (!zone) {
+        gameMasterLogger.info(`User ${character.id} tried to update zone ${data.zoneId} but it does not exist.`)
+        return
+      }
+
+      callback(zone)
+
+      zoneManager.unloadZone(data.zoneId)
+      await zoneManager.loadZone(zone)
+    } catch (error: any) {
+      gameMasterLogger.error(`Error updating zone: ${error.message}`)
+    }
+  })
+}

src/socketEvents/login.ts

@@ -0,0 +1,9 @@
+import { Server } from 'socket.io'
+import { TSocket } from '../utilities/types'
+
+export default function (io: Server, socket: TSocket) {
+  socket.on('login', () => {
+    if (!socket.user) return
+    socket.emit('logged_in', { user: socket.user })
+  })
+}

src/socketEvents/zone/characterJoin.ts

@@ -0,0 +1,59 @@
+import { Server } from 'socket.io'
+import { TSocket } from '../../utilities/types'
+import ZoneRepository from '../../repositories/zoneRepository'
+import { Character, Zone } from '@prisma/client'
+import CharacterManager from '../../managers/characterManager'
+import { gameLogger } from '../../utilities/logger'
+
+interface IPayload {
+  // zoneId: number
+}
+
+interface IResponse {
+  zone: Zone
+  characters: Character[]
+}
+
+/**
+ * Handle character zone request event
+ * @param socket
+ * @param io
+ */
+export default function (io: Server, socket: TSocket) {
+  socket.on('zone:character:join', async (callback: (response: IResponse) => void) => {
+    try {
+      if (!socket.characterId) return
+      const character = CharacterManager.getCharacterFromSocket(socket)
+
+      if (!character) return
+
+      const zone = await ZoneRepository.getById(character.zoneId)
+
+      if (!zone) {
+        console.log(`---Zone not found.`)
+        return
+      }
+
+      if (character?.zoneId) {
+        socket.leave(character.zoneId.toString())
+        io.to(character.zoneId.toString()).emit('zone:character:leave', character)
+      }
+
+      socket.join(zone.id.toString())
+
+      // let other clients know of new character
+      io.to(zone.id.toString()).emit('zone:character:join', character)
+
+      // add character to zone manager
+      // ZoneManager.addCharacterToZone(zone.id, socket.character as Character)
+      // CharacterManager.initCharacter(character as ExtendedCharacter)
+      // ZoneManager.addCharacterToZone(zone.id, socket.character as Character)
+
+      // send over zone and characters to socket
+      callback({ zone, characters: CharacterManager.getCharactersInZone(zone) })
+    } catch (error: any) {
+      gameLogger.error(`Error requesting zone: ${error.message}`)
+      socket.disconnect()
+    }
+  })
+}

src/socketEvents/zone/characterLeave.ts

@@ -0,0 +1,50 @@
+import { Server } from 'socket.io'
+import { TSocket } from '../../utilities/types'
+import ZoneRepository from '../../repositories/zoneRepository'
+import CharacterManager from '../../managers/characterManager'
+import { gameLogger } from '../../utilities/logger'
+
+export default class ZoneLeaveEvent {
+  constructor(
+    private readonly io: Server,
+    private readonly socket: TSocket
+  ) {}
+
+  public listen(): void {
+    this.socket.on('zone:character:leave', this.handleZoneLeave.bind(this))
+  }
+
+  private async handleZoneLeave(): Promise<void> {
+    try {
+      const character = CharacterManager.getCharacterFromSocket(this.socket)
+      if (!character) {
+        gameLogger.error('zone:character:leave error', 'Character not found')
+        return
+      }
+
+      if (!character.zoneId) {
+        gameLogger.error('zone:character:leave error', 'Character not in a zone')
+        return
+      }
+
+      const zone = await ZoneRepository.getById(character.zoneId)
+
+      if (!zone) {
+        gameLogger.error('zone:character:leave error', 'Zone not found')
+        return
+      }
+
+      this.socket.leave(zone.id.toString())
+
+      // let other clients know of character leaving
+      this.io.to(zone.id.toString()).emit('zone:character:leave', character.id)
+
+      // remove character from zone manager
+      await CharacterManager.removeCharacter(character)
+
+      gameLogger.info('zone:character:leave', `Character ${character.id} left zone ${zone.id}`)
+    } catch (error: any) {
+      gameLogger.error('zone:character:leave error', error.message)
+    }
+  }
+}

src/socketEvents/zone/characterMove.ts

@@ -0,0 +1,144 @@
+import { Server } from 'socket.io'
+import { TSocket, ExtendedCharacter } from '../../utilities/types'
+import { CharacterMoveService } from '../../services/character/characterMoveService'
+import { ZoneEventTileService } from '../../services/zoneEventTileService'
+import prisma from '../../utilities/prisma'
+import { ZoneEventTile, ZoneEventTileTeleport } from '@prisma/client'
+import Rotation from '../../utilities/character/rotation'
+import CharacterManager from '../../managers/characterManager'
+import { gameLogger } from '../../utilities/logger'
+import QueueManager from '../../managers/queueManager'
+
+export type ZoneEventTileWithTeleport = ZoneEventTile & {
+  teleport: ZoneEventTileTeleport
+}
+
+export default class CharacterMove {
+  private characterMoveService: CharacterMoveService
+  private zoneEventTileService: ZoneEventTileService
+  private nextPath: { [index: number]: { x: number; y: number }[] } = []
+  private currentZoneId: { [index: number]: number } = []
+
+  constructor(
+    private readonly io: Server,
+    private readonly socket: TSocket
+  ) {
+    this.characterMoveService = new CharacterMoveService()
+    this.zoneEventTileService = new ZoneEventTileService()
+  }
+
+  public listen(): void {
+    this.socket.on('character:initMove', this.handleCharacterMove.bind(this))
+  }
+
+  private async handleCharacterMove({ positionX, positionY }: { positionX: number; positionY: number }): Promise<void> {
+    let character = CharacterManager.getCharacterFromSocket(this.socket)
+    if (!character) {
+      gameLogger.error('character:move error', 'Character not found')
+      return
+    }
+
+    if (!character) {
+      gameLogger.error('character:move error', 'character has not been initialized?')
+      return
+    }
+
+    const path = await this.characterMoveService.calculatePath(character, positionX, positionY)
+    if (!path) {
+      this.io.in(character.zoneId.toString()).emit('character:moveError', 'No valid path found')
+      return
+    }
+
+    if (!character.isMoving && character.resetMovement) {
+      character.resetMovement = false
+    }
+    if (character.isMoving && !character.resetMovement) {
+      character.resetMovement = true
+      this.nextPath[character.id] = path
+    }
+    if (!character.isMoving && !character.resetMovement) {
+      character.isMoving = true
+      this.currentZoneId[character.id] = character.zoneId
+      await this.moveAlongPath(character, path)
+    }
+  }
+
+  private async moveAlongPath(character: ExtendedCharacter, path: Array<{ x: number; y: number }>): Promise<void> {
+    for (let i = 0; i < path.length - 1; i++) {
+      const start = path[i]
+      const end = path[i + 1]
+
+      // if (!(await this.movementValidator.isValidMove(character, end))) {
+      //   break
+      // }
+
+      if (CharacterManager.hasResetMovement(character)) {
+        break
+      }
+
+      character.rotation = Rotation.calculate(start.x, start.y, end.x, end.y)
+
+      const zoneEventTile = await prisma.zoneEventTile.findFirst({
+        where: {
+          zoneId: character.zoneId,
+          positionX: Math.floor(end.x),
+          positionY: Math.floor(end.y)
+        }
+      })
+
+      if (zoneEventTile) {
+        if (zoneEventTile.type === 'BLOCK') {
+          break
+        }
+
+        if (zoneEventTile.type === 'TELEPORT') {
+          const teleportTile = (await prisma.zoneEventTile.findFirst({
+            where: { id: zoneEventTile.id },
+            include: { teleport: true }
+          })) as ZoneEventTileWithTeleport
+
+          if (teleportTile) {
+            await this.handleZoneEventTile(teleportTile)
+            break
+          }
+        }
+      }
+
+      this.characterMoveService.updatePosition(character, end)
+      this.io.in(character.zoneId.toString()).emit('character:move', character)
+
+      await this.characterMoveService.applyMovementDelay()
+    }
+
+    if (CharacterManager.hasResetMovement(character)) {
+      character.resetMovement = false
+      if (this.currentZoneId[character.id] === character.zoneId) {
+        await this.moveAlongPath(character, this.nextPath[character.id])
+      } else {
+        delete this.currentZoneId[character.id]
+        character.isMoving = false
+      }
+    } else {
+      this.finalizeMovement(character)
+    }
+  }
+
+  private async handleZoneEventTile(zoneEventTile: ZoneEventTileWithTeleport): Promise<void> {
+    const character = CharacterManager.getCharacterFromSocket(this.socket)
+    if (!character) {
+      gameLogger.error('character:move error', 'Character not found')
+      return
+    }
+
+    const teleport = zoneEventTile.teleport
+    if (teleport) {
+      await this.zoneEventTileService.handleTeleport(this.io, this.socket, character, teleport)
+      return
+    }
+  }
+
+  private finalizeMovement(character: ExtendedCharacter): void {
+    character.isMoving = false
+    this.io.in(character.zoneId.toString()).emit('character:move', character)
+  }
+}